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

#
# Generated Fri May 12 14:10:06 2023 by generateDS.py version 2.41.5.
# Python 3.8.16 (default, Dec 20 2022, 23:15:53) [MSC v.1900 64 bit (AMD64)]
#
# Command line options:
#   ('-f', '')
#   ('-o', 'E:\\Support\\Rosreestr\\extract_cadastral_plan_territory_v01\\Python\\kpt_11.py')
#   ('--super', 'kpt_11')
#
# Command line arguments:
#   E:\Support\Rosreestr\extract_cadastral_plan_territory_v01\extract_cadastral_plan_territory_v01\extract_cadastral_plan_territory_v01.xsd
#
# Command line:
#   Scripts/generateDS.py -f -o "E:\Support\Rosreestr\extract_cadastral_plan_territory_v01\Python\kpt_11.py" --super="kpt_11" E:\Support\Rosreestr\extract_cadastral_plan_territory_v01\extract_cadastral_plan_territory_v01\extract_cadastral_plan_territory_v01.xsd
#
# Current working directory (os.getcwd()):
#   python
#

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)

#
# Data representation classes.
#


class ExtractCadastralPlanTerritory(GeneratedsSuper):
    """ExtractCadastralPlanTerritory -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    п
    л
    а
    н
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    guid -- Г
    л
    о
    б
    а
    л
    ь
    н
    ы
    й
    у
    н
    и
    к
    а
    л
    ь
    н
    ы
    й
    и
    д
    е
    н
    т
    и
    ф
    и
    к
    а
    т
    о
    р
    д
    о
    к
    у
    м
    е
    н
    т
    а
    details_statement -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    г
    о
    п
    л
    а
    н
    а
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    details_request -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    п
    о
    с
    т
    у
    п
    и
    в
    ш
    е
    г
    о
    з
    а
    п
    р
    о
    с
    а
    cadastral_blocks -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    к
    в
    а
    р
    т
    а
    л
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, guid=None, details_statement=None, details_request=None, cadastral_blocks=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.guid = _cast(None, guid)
        self.guid_nsprefix_ = None
        self.details_statement = details_statement
        self.details_statement_nsprefix_ = None
        self.details_request = details_request
        self.details_request_nsprefix_ = None
        self.cadastral_blocks = cadastral_blocks
        self.cadastral_blocks_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ExtractCadastralPlanTerritory)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ExtractCadastralPlanTerritory.subclass:
            return ExtractCadastralPlanTerritory.subclass(*args_, **kwargs_)
        else:
            return ExtractCadastralPlanTerritory(*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_details_statement(self):
        return self.details_statement
    def set_details_statement(self, details_statement):
        self.details_statement = details_statement
    def get_details_request(self):
        return self.details_request
    def set_details_request(self, details_request):
        self.details_request = details_request
    def get_cadastral_blocks(self):
        return self.cadastral_blocks
    def set_cadastral_blocks(self, cadastral_blocks):
        self.cadastral_blocks = cadastral_blocks
    def get_guid(self):
        return self.guid
    def set_guid(self, guid):
        self.guid = guid
    def validate_sGUID(self, value):
        # Validate type sGUID, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if len(value) > 36:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxLength restriction on sGUID' % {"value" : encode_str_2_3(value), "lineno": lineno} )
                result = False
            if not self.gds_validate_simple_patterns(
                    self.validate_sGUID_patterns_, value):
                self.gds_collector_.add_message('Value "%s" does not match xsd pattern restrictions: %s' % (encode_str_2_3(value), self.validate_sGUID_patterns_, ))
    validate_sGUID_patterns_ = [['^([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})$']]
    def has__content(self):
        if (
            self.details_statement is not None or
            self.details_request is not None or
            self.cadastral_blocks is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ExtractCadastralPlanTerritory', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ExtractCadastralPlanTerritory')
        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_ == 'ExtractCadastralPlanTerritory':
            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_='ExtractCadastralPlanTerritory')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ExtractCadastralPlanTerritory', 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_='ExtractCadastralPlanTerritory'):
        if self.guid is not None and 'guid' not in already_processed:
            already_processed.add('guid')
            outfile.write(' guid=%s' % (quote_attrib(self.guid), ))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ExtractCadastralPlanTerritory', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.details_statement is not None:
            namespaceprefix_ = self.details_statement_nsprefix_ + ':' if (UseCapturedNS_ and self.details_statement_nsprefix_) else ''
            self.details_statement.export(outfile, level, namespaceprefix_, namespacedef_='', name_='details_statement', pretty_print=pretty_print)
        if self.details_request is not None:
            namespaceprefix_ = self.details_request_nsprefix_ + ':' if (UseCapturedNS_ and self.details_request_nsprefix_) else ''
            self.details_request.export(outfile, level, namespaceprefix_, namespacedef_='', name_='details_request', pretty_print=pretty_print)
        if self.cadastral_blocks is not None:
            namespaceprefix_ = self.cadastral_blocks_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_blocks_nsprefix_) else ''
            self.cadastral_blocks.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cadastral_blocks', 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_('guid', node)
        if value is not None and 'guid' not in already_processed:
            already_processed.add('guid')
            self.guid = value
            self.validate_sGUID(self.guid)    # validate type sGUID
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'details_statement':
            obj_ = DetailsStatement.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.details_statement = obj_
            obj_.original_tagname_ = 'details_statement'
        elif nodeName_ == 'details_request':
            obj_ = DetailsRequest.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.details_request = obj_
            obj_.original_tagname_ = 'details_request'
        elif nodeName_ == 'cadastral_blocks':
            obj_ = CadastralBlocks.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cadastral_blocks = obj_
            obj_.original_tagname_ = 'cadastral_blocks'
# end class ExtractCadastralPlanTerritory


class CadastralBlocks(GeneratedsSuper):
    """CadastralBlocks -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    к
    в
    а
    р
    т
    а
    л
    ы
    cadastral_block -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    к
    в
    а
    р
    т
    а
    л
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cadastral_block=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 cadastral_block is None:
            self.cadastral_block = []
        else:
            self.cadastral_block = cadastral_block
        self.cadastral_block_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadastralBlocks)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadastralBlocks.subclass:
            return CadastralBlocks.subclass(*args_, **kwargs_)
        else:
            return CadastralBlocks(*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_cadastral_block(self):
        return self.cadastral_block
    def set_cadastral_block(self, cadastral_block):
        self.cadastral_block = cadastral_block
    def add_cadastral_block(self, value):
        self.cadastral_block.append(value)
    def insert_cadastral_block_at(self, index, value):
        self.cadastral_block.insert(index, value)
    def replace_cadastral_block_at(self, index, value):
        self.cadastral_block[index] = value
    def has__content(self):
        if (
            self.cadastral_block
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadastralBlocks', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadastralBlocks')
        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_ == 'CadastralBlocks':
            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_='CadastralBlocks')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadastralBlocks', 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_='CadastralBlocks'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadastralBlocks', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for cadastral_block_ in self.cadastral_block:
            namespaceprefix_ = self.cadastral_block_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_block_nsprefix_) else ''
            cadastral_block_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cadastral_block', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cadastral_block':
            obj_ = CadastralBlock.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cadastral_block.append(obj_)
            obj_.original_tagname_ = 'cadastral_block'
# end class CadastralBlocks


class CadastralBlock(GeneratedsSuper):
    """CadastralBlock -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    к
    в
    а
    р
    т
    а
    л
    cadastral_number -- Н
    о
    м
    е
    р
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    area_quarter -- П
    л
    о
    щ
    а
    д
    ь
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    record_data -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    в
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    м
    к
    в
    а
    р
    т
    а
    л
    е
    spatial_data -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    к
    в
    а
    р
    т
    а
    л
    а
    subject_boundaries -- С
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    е
    м
    е
    ж
    д
    у
    с
    у
    б
    ъ
    е
    к
    т
    а
    м
    и
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    municipal_boundaries -- С
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    а
    х
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    й
    inhabited_locality_boundaries -- С
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    а
    х
    н
    а
    с
    е
    л
    ё
    н
    н
    ы
    х
    п
    у
    н
    к
    т
    о
    в
    coastline_boundaries -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    е
    р
    е
    г
    о
    в
    ы
    х
    л
    и
    н
    и
    я
    х
    (
    г
    р
    а
    н
    и
    ц
    а
    х
    в
    о
    д
    н
    ы
    х
    о
    б
    ъ
    е
    к
    т
    о
    в
    )
    zones_and_territories_boundaries -- С
    в
    е
    д
    е
    н
    и
    я
    о
    з
    о
    н
    а
    х
    с
    о
    с
    о
    б
    ы
    м
    и
    у
    с
    л
    о
    в
    и
    я
    м
    и
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    й
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    а
    л
    ь
    н
    ы
    х
    з
    о
    н
    а
    х
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    о
    в
    к
    у
    л
    ь
    т
    у
    р
    н
    о
    г
    о
    н
    а
    с
    л
    е
    д
    и
    я
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    я
    х
    о
    п
    е
    р
    е
    ж
    а
    ю
    щ
    е
    г
    о
    с
    о
    ц
    и
    а
    л
    ь
    н
    о
    -
    э
    к
    о
    н
    о
    м
    и
    ч
    е
    с
    к
    о
    г
    о
    р
    а
    з
    в
    и
    т
    и
    я
    ,
    з
    о
    н
    а
    х
    т
    е
    р
    р
    и
    т
    о
    р
    и
    а
    л
    ь
    н
    о
    г
    о
    р
    а
    з
    в
    и
    т
    и
    я
    ,
    и
    г
    о
    р
    н
    ы
    х
    з
    о
    н
    а
    х
    ,
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    а
    х
    ,
    л
    е
    с
    о
    п
    а
    р
    к
    а
    х
    ,
    о
    с
    о
    б
    о
    о
    х
    р
    а
    н
    я
    е
    м
    ы
    х
    п
    р
    и
    р
    о
    д
    н
    ы
    х
    т
    е
    р
    р
    и
    т
    о
    р
    и
    я
    х
    ,
    о
    с
    о
    б
    ы
    х
    э
    к
    о
    н
    о
    м
    и
    ч
    е
    с
    к
    и
    х
    з
    о
    н
    а
    х
    ,
    о
    х
    о
    т
    н
    и
    ч
    ь
    и
    х
    у
    г
    о
    д
    ь
    я
    х
    surveying_project -- С
    в
    е
    д
    е
    н
    и
    я
    о
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    а
    х
    ,
    п
    о
    д
    л
    е
    ж
    а
    щ
    и
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    ю
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    н
    ы
    м
    п
    р
    о
    е
    к
    т
    о
    м
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    oms_points -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    у
    н
    к
    т
    а
    х
    о
    п
    о
    р
    н
    о
    й
    м
    е
    ж
    е
    в
    о
    й
    с
    е
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cadastral_number=None, area_quarter=None, record_data=None, spatial_data=None, subject_boundaries=None, municipal_boundaries=None, inhabited_locality_boundaries=None, coastline_boundaries=None, zones_and_territories_boundaries=None, surveying_project=None, oms_points=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.cadastral_number = cadastral_number
        self.cadastral_number_nsprefix_ = None
        self.area_quarter = area_quarter
        self.area_quarter_nsprefix_ = None
        self.record_data = record_data
        self.record_data_nsprefix_ = None
        self.spatial_data = spatial_data
        self.spatial_data_nsprefix_ = None
        self.subject_boundaries = subject_boundaries
        self.subject_boundaries_nsprefix_ = None
        self.municipal_boundaries = municipal_boundaries
        self.municipal_boundaries_nsprefix_ = None
        self.inhabited_locality_boundaries = inhabited_locality_boundaries
        self.inhabited_locality_boundaries_nsprefix_ = None
        self.coastline_boundaries = coastline_boundaries
        self.coastline_boundaries_nsprefix_ = None
        self.zones_and_territories_boundaries = zones_and_territories_boundaries
        self.zones_and_territories_boundaries_nsprefix_ = None
        self.surveying_project = surveying_project
        self.surveying_project_nsprefix_ = None
        self.oms_points = oms_points
        self.oms_points_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadastralBlock)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadastralBlock.subclass:
            return CadastralBlock.subclass(*args_, **kwargs_)
        else:
            return CadastralBlock(*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_cadastral_number(self):
        return self.cadastral_number
    def set_cadastral_number(self, cadastral_number):
        self.cadastral_number = cadastral_number
    def get_area_quarter(self):
        return self.area_quarter
    def set_area_quarter(self, area_quarter):
        self.area_quarter = area_quarter
    def get_record_data(self):
        return self.record_data
    def set_record_data(self, record_data):
        self.record_data = record_data
    def get_spatial_data(self):
        return self.spatial_data
    def set_spatial_data(self, spatial_data):
        self.spatial_data = spatial_data
    def get_subject_boundaries(self):
        return self.subject_boundaries
    def set_subject_boundaries(self, subject_boundaries):
        self.subject_boundaries = subject_boundaries
    def get_municipal_boundaries(self):
        return self.municipal_boundaries
    def set_municipal_boundaries(self, municipal_boundaries):
        self.municipal_boundaries = municipal_boundaries
    def get_inhabited_locality_boundaries(self):
        return self.inhabited_locality_boundaries
    def set_inhabited_locality_boundaries(self, inhabited_locality_boundaries):
        self.inhabited_locality_boundaries = inhabited_locality_boundaries
    def get_coastline_boundaries(self):
        return self.coastline_boundaries
    def set_coastline_boundaries(self, coastline_boundaries):
        self.coastline_boundaries = coastline_boundaries
    def get_zones_and_territories_boundaries(self):
        return self.zones_and_territories_boundaries
    def set_zones_and_territories_boundaries(self, zones_and_territories_boundaries):
        self.zones_and_territories_boundaries = zones_and_territories_boundaries
    def get_surveying_project(self):
        return self.surveying_project
    def set_surveying_project(self, surveying_project):
        self.surveying_project = surveying_project
    def get_oms_points(self):
        return self.oms_points
    def set_oms_points(self, oms_points):
        self.oms_points = oms_points
    def has__content(self):
        if (
            self.cadastral_number is not None or
            self.area_quarter is not None or
            self.record_data is not None or
            self.spatial_data is not None or
            self.subject_boundaries is not None or
            self.municipal_boundaries is not None or
            self.inhabited_locality_boundaries is not None or
            self.coastline_boundaries is not None or
            self.zones_and_territories_boundaries is not None or
            self.surveying_project is not None or
            self.oms_points is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadastralBlock', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadastralBlock')
        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_ == 'CadastralBlock':
            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_='CadastralBlock')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadastralBlock', 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_='CadastralBlock'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadastralBlock', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.cadastral_number is not None:
            namespaceprefix_ = self.cadastral_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scadastral_number>%s</%scadastral_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cadastral_number), input_name='cadastral_number')), namespaceprefix_ , eol_))
        if self.area_quarter is not None:
            namespaceprefix_ = self.area_quarter_nsprefix_ + ':' if (UseCapturedNS_ and self.area_quarter_nsprefix_) else ''
            self.area_quarter.export(outfile, level, namespaceprefix_, namespacedef_='', name_='area_quarter', pretty_print=pretty_print)
        if self.record_data is not None:
            namespaceprefix_ = self.record_data_nsprefix_ + ':' if (UseCapturedNS_ and self.record_data_nsprefix_) else ''
            self.record_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_data', pretty_print=pretty_print)
        if self.spatial_data is not None:
            namespaceprefix_ = self.spatial_data_nsprefix_ + ':' if (UseCapturedNS_ and self.spatial_data_nsprefix_) else ''
            self.spatial_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='spatial_data', pretty_print=pretty_print)
        if self.subject_boundaries is not None:
            namespaceprefix_ = self.subject_boundaries_nsprefix_ + ':' if (UseCapturedNS_ and self.subject_boundaries_nsprefix_) else ''
            self.subject_boundaries.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subject_boundaries', pretty_print=pretty_print)
        if self.municipal_boundaries is not None:
            namespaceprefix_ = self.municipal_boundaries_nsprefix_ + ':' if (UseCapturedNS_ and self.municipal_boundaries_nsprefix_) else ''
            self.municipal_boundaries.export(outfile, level, namespaceprefix_, namespacedef_='', name_='municipal_boundaries', pretty_print=pretty_print)
        if self.inhabited_locality_boundaries is not None:
            namespaceprefix_ = self.inhabited_locality_boundaries_nsprefix_ + ':' if (UseCapturedNS_ and self.inhabited_locality_boundaries_nsprefix_) else ''
            self.inhabited_locality_boundaries.export(outfile, level, namespaceprefix_, namespacedef_='', name_='inhabited_locality_boundaries', pretty_print=pretty_print)
        if self.coastline_boundaries is not None:
            namespaceprefix_ = self.coastline_boundaries_nsprefix_ + ':' if (UseCapturedNS_ and self.coastline_boundaries_nsprefix_) else ''
            self.coastline_boundaries.export(outfile, level, namespaceprefix_, namespacedef_='', name_='coastline_boundaries', pretty_print=pretty_print)
        if self.zones_and_territories_boundaries is not None:
            namespaceprefix_ = self.zones_and_territories_boundaries_nsprefix_ + ':' if (UseCapturedNS_ and self.zones_and_territories_boundaries_nsprefix_) else ''
            self.zones_and_territories_boundaries.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zones_and_territories_boundaries', pretty_print=pretty_print)
        if self.surveying_project is not None:
            namespaceprefix_ = self.surveying_project_nsprefix_ + ':' if (UseCapturedNS_ and self.surveying_project_nsprefix_) else ''
            self.surveying_project.export(outfile, level, namespaceprefix_, namespacedef_='', name_='surveying_project', pretty_print=pretty_print)
        if self.oms_points is not None:
            namespaceprefix_ = self.oms_points_nsprefix_ + ':' if (UseCapturedNS_ and self.oms_points_nsprefix_) else ''
            self.oms_points.export(outfile, level, namespaceprefix_, namespacedef_='', name_='oms_points', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cadastral_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cadastral_number')
            value_ = self.gds_validate_string(value_, node, 'cadastral_number')
            self.cadastral_number = value_
            self.cadastral_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'area_quarter':
            obj_ = AreaQuarter.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.area_quarter = obj_
            obj_.original_tagname_ = 'area_quarter'
        elif nodeName_ == 'record_data':
            obj_ = RecordData.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_data = obj_
            obj_.original_tagname_ = 'record_data'
        elif nodeName_ == 'spatial_data':
            obj_ = SpatialDataType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.spatial_data = obj_
            obj_.original_tagname_ = 'spatial_data'
        elif nodeName_ == 'subject_boundaries':
            obj_ = SubjectBoundariesType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.subject_boundaries = obj_
            obj_.original_tagname_ = 'subject_boundaries'
        elif nodeName_ == 'municipal_boundaries':
            obj_ = MunicipalBoundariesType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.municipal_boundaries = obj_
            obj_.original_tagname_ = 'municipal_boundaries'
        elif nodeName_ == 'inhabited_locality_boundaries':
            obj_ = InhabitedLocalityBoundariesType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.inhabited_locality_boundaries = obj_
            obj_.original_tagname_ = 'inhabited_locality_boundaries'
        elif nodeName_ == 'coastline_boundaries':
            obj_ = CoastlineBoundariesType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.coastline_boundaries = obj_
            obj_.original_tagname_ = 'coastline_boundaries'
        elif nodeName_ == 'zones_and_territories_boundaries':
            obj_ = ZonesAndTerritoriesBoundariesType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.zones_and_territories_boundaries = obj_
            obj_.original_tagname_ = 'zones_and_territories_boundaries'
        elif nodeName_ == 'surveying_project':
            obj_ = SurveyingProjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.surveying_project = obj_
            obj_.original_tagname_ = 'surveying_project'
        elif nodeName_ == 'oms_points':
            obj_ = OMSPoints.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.oms_points = obj_
            obj_.original_tagname_ = 'oms_points'
# end class CadastralBlock


class DetailsStatement(GeneratedsSuper):
    """DetailsStatement -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    в
    ы
    п
    и
    с
    к
    и
    group_top_requisites -- Г
    р
    у
    п
    п
    а
    в
    е
    р
    х
    н
    и
    х
    р
    е
    к
    в
    и
    з
    и
    т
    о
    в
    group_lower_requisites -- Г
    р
    у
    п
    п
    а
    н
    и
    ж
    н
    и
    х
    р
    е
    к
    в
    и
    з
    и
    т
    о
    в
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, group_top_requisites=None, group_lower_requisites=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.group_top_requisites = group_top_requisites
        self.group_top_requisites_nsprefix_ = None
        self.group_lower_requisites = group_lower_requisites
        self.group_lower_requisites_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DetailsStatement)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DetailsStatement.subclass:
            return DetailsStatement.subclass(*args_, **kwargs_)
        else:
            return DetailsStatement(*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_group_top_requisites(self):
        return self.group_top_requisites
    def set_group_top_requisites(self, group_top_requisites):
        self.group_top_requisites = group_top_requisites
    def get_group_lower_requisites(self):
        return self.group_lower_requisites
    def set_group_lower_requisites(self, group_lower_requisites):
        self.group_lower_requisites = group_lower_requisites
    def has__content(self):
        if (
            self.group_top_requisites is not None or
            self.group_lower_requisites is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DetailsStatement', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DetailsStatement')
        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_ == 'DetailsStatement':
            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_='DetailsStatement')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DetailsStatement', 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_='DetailsStatement'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DetailsStatement', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.group_top_requisites is not None:
            namespaceprefix_ = self.group_top_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.group_top_requisites_nsprefix_) else ''
            self.group_top_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='group_top_requisites', pretty_print=pretty_print)
        if self.group_lower_requisites is not None:
            namespaceprefix_ = self.group_lower_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.group_lower_requisites_nsprefix_) else ''
            self.group_lower_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='group_lower_requisites', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'group_top_requisites':
            obj_ = group_top_requisitesType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.group_top_requisites = obj_
            obj_.original_tagname_ = 'group_top_requisites'
        elif nodeName_ == 'group_lower_requisites':
            obj_ = group_lower_requisitesType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.group_lower_requisites = obj_
            obj_.original_tagname_ = 'group_lower_requisites'
# end class DetailsStatement


class DetailsStatementRealty(GeneratedsSuper):
    """DetailsStatementRealty -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    в
    ы
    п
    и
    с
    к
    и
    (
    п
    о
    о
    б
    ъ
    е
    к
    т
    у
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    т
    и
    )
    group_top_requisites -- Г
    р
    у
    п
    п
    а
    в
    е
    р
    х
    н
    и
    х
    р
    е
    к
    в
    и
    з
    и
    т
    о
    в
    group_lower_requisites -- Г
    р
    у
    п
    п
    а
    н
    и
    ж
    н
    и
    х
    р
    е
    к
    в
    и
    з
    и
    т
    о
    в
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, group_top_requisites=None, group_lower_requisites=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.group_top_requisites = group_top_requisites
        self.group_top_requisites_nsprefix_ = None
        self.group_lower_requisites = group_lower_requisites
        self.group_lower_requisites_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DetailsStatementRealty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DetailsStatementRealty.subclass:
            return DetailsStatementRealty.subclass(*args_, **kwargs_)
        else:
            return DetailsStatementRealty(*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_group_top_requisites(self):
        return self.group_top_requisites
    def set_group_top_requisites(self, group_top_requisites):
        self.group_top_requisites = group_top_requisites
    def get_group_lower_requisites(self):
        return self.group_lower_requisites
    def set_group_lower_requisites(self, group_lower_requisites):
        self.group_lower_requisites = group_lower_requisites
    def has__content(self):
        if (
            self.group_top_requisites is not None or
            self.group_lower_requisites is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DetailsStatementRealty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DetailsStatementRealty')
        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_ == 'DetailsStatementRealty':
            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_='DetailsStatementRealty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DetailsStatementRealty', 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_='DetailsStatementRealty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DetailsStatementRealty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.group_top_requisites is not None:
            namespaceprefix_ = self.group_top_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.group_top_requisites_nsprefix_) else ''
            self.group_top_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='group_top_requisites', pretty_print=pretty_print)
        if self.group_lower_requisites is not None:
            namespaceprefix_ = self.group_lower_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.group_lower_requisites_nsprefix_) else ''
            self.group_lower_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='group_lower_requisites', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'group_top_requisites':
            obj_ = group_top_requisitesType1.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.group_top_requisites = obj_
            obj_.original_tagname_ = 'group_top_requisites'
        elif nodeName_ == 'group_lower_requisites':
            obj_ = group_lower_requisitesType2.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.group_lower_requisites = obj_
            obj_.original_tagname_ = 'group_lower_requisites'
# end class DetailsStatementRealty


class DetailsRequest(GeneratedsSuper):
    """DetailsRequest -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    п
    о
    с
    т
    у
    п
    и
    в
    ш
    е
    г
    о
    з
    а
    п
    р
    о
    с
    а
    date_received_request -- Д
    а
    т
    а
    п
    о
    с
    т
    у
    п
    и
    в
    ш
    е
    г
    о
    з
    а
    п
    р
    о
    с
    а
    date_receipt_request_reg_authority_rights -- Д
    а
    т
    а
    п
    о
    л
    у
    ч
    е
    н
    и
    я
    з
    а
    п
    р
    о
    с
    а
    о
    р
    г
    а
    н
    о
    м
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    р
    а
    в
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, date_received_request=None, date_receipt_request_reg_authority_rights=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(date_received_request, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_received_request, '%Y-%m-%d').date()
        else:
            initvalue_ = date_received_request
        self.date_received_request = initvalue_
        self.date_received_request_nsprefix_ = None
        if isinstance(date_receipt_request_reg_authority_rights, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_receipt_request_reg_authority_rights, '%Y-%m-%d').date()
        else:
            initvalue_ = date_receipt_request_reg_authority_rights
        self.date_receipt_request_reg_authority_rights = initvalue_
        self.date_receipt_request_reg_authority_rights_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DetailsRequest)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DetailsRequest.subclass:
            return DetailsRequest.subclass(*args_, **kwargs_)
        else:
            return DetailsRequest(*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_date_received_request(self):
        return self.date_received_request
    def set_date_received_request(self, date_received_request):
        self.date_received_request = date_received_request
    def get_date_receipt_request_reg_authority_rights(self):
        return self.date_receipt_request_reg_authority_rights
    def set_date_receipt_request_reg_authority_rights(self, date_receipt_request_reg_authority_rights):
        self.date_receipt_request_reg_authority_rights = date_receipt_request_reg_authority_rights
    def has__content(self):
        if (
            self.date_received_request is not None or
            self.date_receipt_request_reg_authority_rights is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DetailsRequest', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DetailsRequest')
        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_ == 'DetailsRequest':
            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_='DetailsRequest')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DetailsRequest', 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_='DetailsRequest'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DetailsRequest', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.date_received_request is not None:
            namespaceprefix_ = self.date_received_request_nsprefix_ + ':' if (UseCapturedNS_ and self.date_received_request_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_received_request>%s</%sdate_received_request>%s' % (namespaceprefix_ , self.gds_format_date(self.date_received_request, input_name='date_received_request'), namespaceprefix_ , eol_))
        if self.date_receipt_request_reg_authority_rights is not None:
            namespaceprefix_ = self.date_receipt_request_reg_authority_rights_nsprefix_ + ':' if (UseCapturedNS_ and self.date_receipt_request_reg_authority_rights_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_receipt_request_reg_authority_rights>%s</%sdate_receipt_request_reg_authority_rights>%s' % (namespaceprefix_ , self.gds_format_date(self.date_receipt_request_reg_authority_rights, input_name='date_receipt_request_reg_authority_rights'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'date_received_request':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_received_request = dval_
            self.date_received_request_nsprefix_ = child_.prefix
        elif nodeName_ == 'date_receipt_request_reg_authority_rights':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_receipt_request_reg_authority_rights = dval_
            self.date_receipt_request_reg_authority_rights_nsprefix_ = child_.prefix
# end class DetailsRequest


class DetailsRequestPeriod(GeneratedsSuper):
    """DetailsRequestPeriod -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    п
    о
    с
    т
    у
    п
    и
    в
    ш
    е
    г
    о
    з
    а
    п
    р
    о
    с
    а
    и
    п
    е
    р
    и
    о
    д
    ,
    з
    а
    к
    о
    т
    о
    р
    ы
    й
    з
    а
    п
    р
    а
    ш
    и
    в
    а
    е
    т
    с
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    date_received_request -- Д
    а
    т
    а
    п
    о
    с
    т
    у
    п
    и
    в
    ш
    е
    г
    о
    з
    а
    п
    р
    о
    с
    а
    date_receipt_request_reg_authority_rights -- Д
    а
    т
    а
    п
    о
    л
    у
    ч
    е
    н
    и
    я
    з
    а
    п
    р
    о
    с
    а
    о
    р
    г
    а
    н
    о
    м
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    р
    а
    в
    period -- П
    е
    р
    и
    о
    д
    в
    р
    е
    м
    е
    н
    и
    ,
    з
    а
    к
    о
    т
    о
    р
    ы
    й
    з
    а
    п
    р
    а
    ш
    и
    в
    а
    е
    т
    с
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, date_received_request=None, date_receipt_request_reg_authority_rights=None, period=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(date_received_request, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_received_request, '%Y-%m-%d').date()
        else:
            initvalue_ = date_received_request
        self.date_received_request = initvalue_
        self.date_received_request_nsprefix_ = None
        if isinstance(date_receipt_request_reg_authority_rights, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_receipt_request_reg_authority_rights, '%Y-%m-%d').date()
        else:
            initvalue_ = date_receipt_request_reg_authority_rights
        self.date_receipt_request_reg_authority_rights = initvalue_
        self.date_receipt_request_reg_authority_rights_nsprefix_ = None
        self.period = period
        self.period_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DetailsRequestPeriod)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DetailsRequestPeriod.subclass:
            return DetailsRequestPeriod.subclass(*args_, **kwargs_)
        else:
            return DetailsRequestPeriod(*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_date_received_request(self):
        return self.date_received_request
    def set_date_received_request(self, date_received_request):
        self.date_received_request = date_received_request
    def get_date_receipt_request_reg_authority_rights(self):
        return self.date_receipt_request_reg_authority_rights
    def set_date_receipt_request_reg_authority_rights(self, date_receipt_request_reg_authority_rights):
        self.date_receipt_request_reg_authority_rights = date_receipt_request_reg_authority_rights
    def get_period(self):
        return self.period
    def set_period(self, period):
        self.period = period
    def has__content(self):
        if (
            self.date_received_request is not None or
            self.date_receipt_request_reg_authority_rights is not None or
            self.period is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DetailsRequestPeriod', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DetailsRequestPeriod')
        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_ == 'DetailsRequestPeriod':
            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_='DetailsRequestPeriod')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DetailsRequestPeriod', 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_='DetailsRequestPeriod'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DetailsRequestPeriod', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.date_received_request is not None:
            namespaceprefix_ = self.date_received_request_nsprefix_ + ':' if (UseCapturedNS_ and self.date_received_request_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_received_request>%s</%sdate_received_request>%s' % (namespaceprefix_ , self.gds_format_date(self.date_received_request, input_name='date_received_request'), namespaceprefix_ , eol_))
        if self.date_receipt_request_reg_authority_rights is not None:
            namespaceprefix_ = self.date_receipt_request_reg_authority_rights_nsprefix_ + ':' if (UseCapturedNS_ and self.date_receipt_request_reg_authority_rights_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_receipt_request_reg_authority_rights>%s</%sdate_receipt_request_reg_authority_rights>%s' % (namespaceprefix_ , self.gds_format_date(self.date_receipt_request_reg_authority_rights, input_name='date_receipt_request_reg_authority_rights'), namespaceprefix_ , eol_))
        if self.period is not None:
            namespaceprefix_ = self.period_nsprefix_ + ':' if (UseCapturedNS_ and self.period_nsprefix_) else ''
            self.period.export(outfile, level, namespaceprefix_, namespacedef_='', name_='period', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'date_received_request':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_received_request = dval_
            self.date_received_request_nsprefix_ = child_.prefix
        elif nodeName_ == 'date_receipt_request_reg_authority_rights':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_receipt_request_reg_authority_rights = dval_
            self.date_receipt_request_reg_authority_rights_nsprefix_ = child_.prefix
        elif nodeName_ == 'period':
            obj_ = PeriodStartEnd.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.period = obj_
            obj_.original_tagname_ = 'period'
# end class DetailsRequestPeriod


class PeriodStartEndAvailable(GeneratedsSuper):
    """PeriodStartEndAvailable -- Д
    а
    т
    а
    ,
    п
    о
    с
    о
    с
    т
    о
    я
    н
    и
    ю
    н
    а
    к
    о
    т
    о
    р
    у
    ю
    и
    л
    и
    п
    е
    р
    и
    о
    д
    ,
    з
    а
    к
    о
    т
    о
    р
    ы
    й
    з
    а
    п
    р
    о
    ш
    е
    н
    ы
    с
    в
    е
    д
    е
    н
    и
    я
    date_available_information -- Д
    а
    т
    а
    ,
    п
    о
    с
    о
    с
    т
    о
    я
    н
    и
    ю
    н
    а
    к
    о
    т
    о
    р
    у
    ю
    з
    а
    п
    р
    о
    ш
    е
    н
    ы
    с
    в
    е
    д
    е
    н
    и
    я
    period_start_date -- Д
    а
    т
    а
    н
    а
    ч
    а
    л
    а
    п
    е
    р
    и
    о
    д
    а
    period_end_date -- Д
    а
    т
    а
    о
    к
    о
    н
    ч
    а
    н
    и
    я
    п
    е
    р
    и
    о
    д
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, date_available_information=None, period_start_date=None, period_end_date=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(date_available_information, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_available_information, '%Y-%m-%d').date()
        else:
            initvalue_ = date_available_information
        self.date_available_information = initvalue_
        self.date_available_information_nsprefix_ = None
        if isinstance(period_start_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(period_start_date, '%Y-%m-%d').date()
        else:
            initvalue_ = period_start_date
        self.period_start_date = initvalue_
        self.period_start_date_nsprefix_ = None
        if isinstance(period_end_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(period_end_date, '%Y-%m-%d').date()
        else:
            initvalue_ = period_end_date
        self.period_end_date = initvalue_
        self.period_end_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PeriodStartEndAvailable)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PeriodStartEndAvailable.subclass:
            return PeriodStartEndAvailable.subclass(*args_, **kwargs_)
        else:
            return PeriodStartEndAvailable(*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_date_available_information(self):
        return self.date_available_information
    def set_date_available_information(self, date_available_information):
        self.date_available_information = date_available_information
    def get_period_start_date(self):
        return self.period_start_date
    def set_period_start_date(self, period_start_date):
        self.period_start_date = period_start_date
    def get_period_end_date(self):
        return self.period_end_date
    def set_period_end_date(self, period_end_date):
        self.period_end_date = period_end_date
    def has__content(self):
        if (
            self.date_available_information is not None or
            self.period_start_date is not None or
            self.period_end_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodStartEndAvailable', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PeriodStartEndAvailable')
        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_ == 'PeriodStartEndAvailable':
            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_='PeriodStartEndAvailable')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PeriodStartEndAvailable', 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_='PeriodStartEndAvailable'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodStartEndAvailable', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.date_available_information is not None:
            namespaceprefix_ = self.date_available_information_nsprefix_ + ':' if (UseCapturedNS_ and self.date_available_information_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_available_information>%s</%sdate_available_information>%s' % (namespaceprefix_ , self.gds_format_date(self.date_available_information, input_name='date_available_information'), namespaceprefix_ , eol_))
        if self.period_start_date is not None:
            namespaceprefix_ = self.period_start_date_nsprefix_ + ':' if (UseCapturedNS_ and self.period_start_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%speriod_start_date>%s</%speriod_start_date>%s' % (namespaceprefix_ , self.gds_format_date(self.period_start_date, input_name='period_start_date'), namespaceprefix_ , eol_))
        if self.period_end_date is not None:
            namespaceprefix_ = self.period_end_date_nsprefix_ + ':' if (UseCapturedNS_ and self.period_end_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%speriod_end_date>%s</%speriod_end_date>%s' % (namespaceprefix_ , self.gds_format_date(self.period_end_date, input_name='period_end_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'date_available_information':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_available_information = dval_
            self.date_available_information_nsprefix_ = child_.prefix
        elif nodeName_ == 'period_start_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.period_start_date = dval_
            self.period_start_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'period_end_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.period_end_date = dval_
            self.period_end_date_nsprefix_ = child_.prefix
# end class PeriodStartEndAvailable


class PeriodStartEnd(GeneratedsSuper):
    """PeriodStartEnd -- П
    е
    р
    и
    о
    д
    в
    р
    е
    м
    е
    н
    и
    (
    д
    а
    т
    ы
    н
    а
    ч
    а
    л
    а
    ,
    о
    к
    о
    н
    ч
    а
    н
    и
    я
    п
    е
    р
    и
    о
    д
    а
    )
    period_start_date -- Д
    а
    т
    а
    н
    а
    ч
    а
    л
    а
    п
    е
    р
    и
    о
    д
    а
    period_end_date -- Д
    а
    т
    а
    о
    к
    о
    н
    ч
    а
    н
    и
    я
    п
    е
    р
    и
    о
    д
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, period_start_date=None, period_end_date=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(period_start_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(period_start_date, '%Y-%m-%d').date()
        else:
            initvalue_ = period_start_date
        self.period_start_date = initvalue_
        self.period_start_date_nsprefix_ = None
        if isinstance(period_end_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(period_end_date, '%Y-%m-%d').date()
        else:
            initvalue_ = period_end_date
        self.period_end_date = initvalue_
        self.period_end_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PeriodStartEnd)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PeriodStartEnd.subclass:
            return PeriodStartEnd.subclass(*args_, **kwargs_)
        else:
            return PeriodStartEnd(*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_period_start_date(self):
        return self.period_start_date
    def set_period_start_date(self, period_start_date):
        self.period_start_date = period_start_date
    def get_period_end_date(self):
        return self.period_end_date
    def set_period_end_date(self, period_end_date):
        self.period_end_date = period_end_date
    def has__content(self):
        if (
            self.period_start_date is not None or
            self.period_end_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodStartEnd', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PeriodStartEnd')
        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_ == 'PeriodStartEnd':
            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_='PeriodStartEnd')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PeriodStartEnd', 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_='PeriodStartEnd'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodStartEnd', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.period_start_date is not None:
            namespaceprefix_ = self.period_start_date_nsprefix_ + ':' if (UseCapturedNS_ and self.period_start_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%speriod_start_date>%s</%speriod_start_date>%s' % (namespaceprefix_ , self.gds_format_date(self.period_start_date, input_name='period_start_date'), namespaceprefix_ , eol_))
        if self.period_end_date is not None:
            namespaceprefix_ = self.period_end_date_nsprefix_ + ':' if (UseCapturedNS_ and self.period_end_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%speriod_end_date>%s</%speriod_end_date>%s' % (namespaceprefix_ , self.gds_format_date(self.period_end_date, input_name='period_end_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'period_start_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.period_start_date = dval_
            self.period_start_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'period_end_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.period_end_date = dval_
            self.period_end_date_nsprefix_ = child_.prefix
# end class PeriodStartEnd


class Dict(GeneratedsSuper):
    """Dict -- С
    п
    р
    а
    в
    о
    ч
    н
    и
    к
    Н
    С
    И
    code -- К
    о
    д
    с
    п
    р
    а
    в
    о
    ч
    н
    и
    к
    а
    Н
    С
    И
    value -- Т
    е
    к
    с
    т
    о
    в
    о
    е
    з
    н
    а
    ч
    е
    н
    и
    е
    ,
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    у
    ю
    щ
    е
    е
    к
    о
    д
    у
    с
    п
    р
    а
    в
    о
    ч
    н
    и
    к
    а
    Н
    С
    И
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, code=None, value=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.code = code
        self.code_nsprefix_ = None
        self.value = value
        self.value_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Dict)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Dict.subclass:
            return Dict.subclass(*args_, **kwargs_)
        else:
            return Dict(*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_value(self):
        return self.value
    def set_value(self, value):
        self.value = value
    def has__content(self):
        if (
            self.code is not None or
            self.value is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Dict', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Dict')
        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_ == 'Dict':
            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_='Dict')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Dict', 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_='Dict'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Dict', 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.value is not None:
            namespaceprefix_ = self.value_nsprefix_ + ':' if (UseCapturedNS_ and self.value_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%svalue>%s</%svalue>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.value), input_name='value')), 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):
        pass
    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_ == 'value':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'value')
            value_ = self.gds_validate_string(value_, node, 'value')
            self.value = value_
            self.value_nsprefix_ = child_.prefix
# end class Dict


class Materials(GeneratedsSuper):
    """Materials -- М
    а
    т
    е
    р
    и
    а
    л
    ы
    н
    а
    р
    у
    ж
    н
    ы
    х
    с
    т
    е
    н
    з
    д
    а
    н
    и
    я
    material -- М
    а
    т
    е
    р
    и
    а
    л
    н
    а
    р
    у
    ж
    н
    ы
    х
    с
    т
    е
    н
    з
    д
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, material=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 material is None:
            self.material = []
        else:
            self.material = material
        self.material_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Materials)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Materials.subclass:
            return Materials.subclass(*args_, **kwargs_)
        else:
            return Materials(*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_material(self):
        return self.material
    def set_material(self, material):
        self.material = material
    def add_material(self, value):
        self.material.append(value)
    def insert_material_at(self, index, value):
        self.material.insert(index, value)
    def replace_material_at(self, index, value):
        self.material[index] = value
    def has__content(self):
        if (
            self.material
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Materials', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Materials')
        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_ == 'Materials':
            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_='Materials')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Materials', 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_='Materials'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Materials', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for material_ in self.material:
            namespaceprefix_ = self.material_nsprefix_ + ':' if (UseCapturedNS_ and self.material_nsprefix_) else ''
            material_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='material', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'material':
            obj_ = Material.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.material.append(obj_)
            obj_.original_tagname_ = 'material'
# end class Materials


class Material(GeneratedsSuper):
    """Material -- М
    а
    т
    е
    р
    и
    а
    л
    н
    а
    р
    у
    ж
    н
    ы
    х
    с
    т
    е
    н
    з
    д
    а
    н
    и
    я
    material -- М
    а
    т
    е
    р
    и
    а
    л
    с
    т
    е
    н
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, material=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.material = material
        self.material_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Material)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Material.subclass:
            return Material.subclass(*args_, **kwargs_)
        else:
            return Material(*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_material(self):
        return self.material
    def set_material(self, material):
        self.material = material
    def has__content(self):
        if (
            self.material is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Material', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Material')
        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_ == 'Material':
            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_='Material')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Material', 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_='Material'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Material', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.material is not None:
            namespaceprefix_ = self.material_nsprefix_ + ':' if (UseCapturedNS_ and self.material_nsprefix_) else ''
            self.material.export(outfile, level, namespaceprefix_, namespacedef_='', name_='material', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'material':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.material = obj_
            obj_.original_tagname_ = 'material'
# end class Material


class CulturalHeritage(GeneratedsSuper):
    """CulturalHeritage -- С
    в
    е
    д
    е
    н
    и
    я
    о
    в
    к
    л
    ю
    ч
    е
    н
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    в
    е
    д
    и
    н
    ы
    й
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    й
    р
    е
    е
    с
    т
    р
    о
    б
    ъ
    е
    к
    т
    о
    в
    к
    у
    л
    ь
    т
    у
    р
    н
    о
    г
    о
    н
    а
    с
    л
    е
    д
    и
    я
    (
    п
    а
    м
    я
    т
    н
    и
    к
    о
    в
    и
    с
    т
    о
    р
    и
    и
    и
    к
    у
    л
    ь
    т
    у
    р
    ы
    )
    н
    а
    р
    о
    д
    о
    в
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    heritage_decisions -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    р
    е
    ш
    е
    н
    и
    й
    included -- В
    к
    л
    ю
    ч
    е
    н
    в
    р
    е
    е
    с
    т
    р
    о
    б
    ъ
    е
    к
    т
    о
    в
    к
    у
    л
    ь
    т
    у
    р
    н
    о
    г
    о
    н
    а
    с
    л
    е
    д
    и
    я
    и
    л
    и
    я
    в
    л
    я
    е
    т
    с
    я
    в
    ы
    я
    в
    л
    е
    н
    н
    ы
    м
    о
    б
    ъ
    е
    к
    т
    о
    м
    reg_number -- Р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    о
    н
    н
    ы
    й
    н
    о
    м
    е
    р
    (
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    о
    н
    н
    ы
    й
    н
    о
    м
    е
    р
    у
    ч
    е
    т
    н
    о
    й
    к
    а
    р
    т
    ы
    )
    kind_object -- В
    и
    д
    о
    б
    ъ
    е
    к
    т
    а
    name_object -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, heritage_decisions=None, included=None, reg_number=None, kind_object=None, name_object=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.heritage_decisions = heritage_decisions
        self.heritage_decisions_nsprefix_ = None
        self.included = included
        self.included_nsprefix_ = None
        self.reg_number = reg_number
        self.reg_number_nsprefix_ = None
        self.kind_object = kind_object
        self.kind_object_nsprefix_ = None
        self.name_object = name_object
        self.name_object_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CulturalHeritage)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CulturalHeritage.subclass:
            return CulturalHeritage.subclass(*args_, **kwargs_)
        else:
            return CulturalHeritage(*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_heritage_decisions(self):
        return self.heritage_decisions
    def set_heritage_decisions(self, heritage_decisions):
        self.heritage_decisions = heritage_decisions
    def get_included(self):
        return self.included
    def set_included(self, included):
        self.included = included
    def get_reg_number(self):
        return self.reg_number
    def set_reg_number(self, reg_number):
        self.reg_number = reg_number
    def get_kind_object(self):
        return self.kind_object
    def set_kind_object(self, kind_object):
        self.kind_object = kind_object
    def get_name_object(self):
        return self.name_object
    def set_name_object(self, name_object):
        self.name_object = name_object
    def has__content(self):
        if (
            self.heritage_decisions is not None or
            self.included is not None or
            self.reg_number is not None or
            self.kind_object is not None or
            self.name_object is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CulturalHeritage', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CulturalHeritage')
        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_ == 'CulturalHeritage':
            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_='CulturalHeritage')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CulturalHeritage', 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_='CulturalHeritage'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CulturalHeritage', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.heritage_decisions is not None:
            namespaceprefix_ = self.heritage_decisions_nsprefix_ + ':' if (UseCapturedNS_ and self.heritage_decisions_nsprefix_) else ''
            self.heritage_decisions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='heritage_decisions', pretty_print=pretty_print)
        if self.included is not None:
            namespaceprefix_ = self.included_nsprefix_ + ':' if (UseCapturedNS_ and self.included_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sincluded>%s</%sincluded>%s' % (namespaceprefix_ , self.gds_format_boolean(self.included, input_name='included'), namespaceprefix_ , eol_))
        if self.reg_number is not None:
            namespaceprefix_ = self.reg_number_nsprefix_ + ':' if (UseCapturedNS_ and self.reg_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreg_number>%s</%sreg_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.reg_number), input_name='reg_number')), namespaceprefix_ , eol_))
        if self.kind_object is not None:
            namespaceprefix_ = self.kind_object_nsprefix_ + ':' if (UseCapturedNS_ and self.kind_object_nsprefix_) else ''
            self.kind_object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kind_object', pretty_print=pretty_print)
        if self.name_object is not None:
            namespaceprefix_ = self.name_object_nsprefix_ + ':' if (UseCapturedNS_ and self.name_object_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_object>%s</%sname_object>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_object), input_name='name_object')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'heritage_decisions':
            obj_ = heritage_decisionsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.heritage_decisions = obj_
            obj_.original_tagname_ = 'heritage_decisions'
        elif nodeName_ == 'included':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'included')
            ival_ = self.gds_validate_boolean(ival_, node, 'included')
            self.included = ival_
            self.included_nsprefix_ = child_.prefix
        elif nodeName_ == 'reg_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'reg_number')
            value_ = self.gds_validate_string(value_, node, 'reg_number')
            self.reg_number = value_
            self.reg_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'kind_object':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.kind_object = obj_
            obj_.original_tagname_ = 'kind_object'
        elif nodeName_ == 'name_object':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_object')
            value_ = self.gds_validate_string(value_, node, 'name_object')
            self.name_object = value_
            self.name_object_nsprefix_ = child_.prefix
# end class CulturalHeritage


class LandArea(GeneratedsSuper):
    """LandArea -- П
    л
    о
    щ
    а
    д
    ь
    и
    п
    о
    г
    р
    е
    ш
    н
    о
    с
    т
    ь
    в
    ы
    ч
    и
    с
    л
    е
    н
    и
    я
    value -- З
    н
    а
    ч
    е
    н
    и
    е
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    inaccuracy -- П
    о
    г
    р
    е
    ш
    н
    о
    с
    т
    ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, value=None, inaccuracy=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.value = value
        self.validate_PositiveDecimal(self.value)
        self.value_nsprefix_ = None
        self.inaccuracy = inaccuracy
        self.validate_PositiveDecimal(self.inaccuracy)
        self.inaccuracy_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LandArea)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LandArea.subclass:
            return LandArea.subclass(*args_, **kwargs_)
        else:
            return LandArea(*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_value(self):
        return self.value
    def set_value(self, value):
        self.value = value
    def get_inaccuracy(self):
        return self.inaccuracy
    def set_inaccuracy(self, inaccuracy):
        self.inaccuracy = inaccuracy
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.value is not None or
            self.inaccuracy is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandArea', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LandArea')
        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_ == 'LandArea':
            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_='LandArea')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LandArea', 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_='LandArea'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandArea', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.value is not None:
            namespaceprefix_ = self.value_nsprefix_ + ':' if (UseCapturedNS_ and self.value_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%svalue>%s</%svalue>%s' % (namespaceprefix_ , self.gds_format_decimal(self.value, input_name='value'), namespaceprefix_ , eol_))
        if self.inaccuracy is not None:
            namespaceprefix_ = self.inaccuracy_nsprefix_ + ':' if (UseCapturedNS_ and self.inaccuracy_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sinaccuracy>%s</%sinaccuracy>%s' % (namespaceprefix_ , self.gds_format_decimal(self.inaccuracy, input_name='inaccuracy'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'value' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'value')
            fval_ = self.gds_validate_decimal(fval_, node, 'value')
            self.value = fval_
            self.value_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.value)
        elif nodeName_ == 'inaccuracy' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'inaccuracy')
            fval_ = self.gds_validate_decimal(fval_, node, 'inaccuracy')
            self.inaccuracy = fval_
            self.inaccuracy_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.inaccuracy)
# end class LandArea


class AreaContours(GeneratedsSuper):
    """AreaContours -- П
    л
    о
    щ
    а
    д
    ь
    к
    о
    н
    т
    у
    р
    а
    type -- В
    и
    д
    п
    л
    о
    щ
    а
    д
    и
    value -- З
    н
    а
    ч
    е
    н
    и
    е
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_=None, value=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.type_ = type_
        self.type__nsprefix_ = None
        self.value = value
        self.validate_PositiveDecimal(self.value)
        self.value_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AreaContours)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AreaContours.subclass:
            return AreaContours.subclass(*args_, **kwargs_)
        else:
            return AreaContours(*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_type(self):
        return self.type_
    def set_type(self, type_):
        self.type_ = type_
    def get_value(self):
        return self.value
    def set_value(self, value):
        self.value = value
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.type_ is not None or
            self.value is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AreaContours', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AreaContours')
        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_ == 'AreaContours':
            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_='AreaContours')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AreaContours', 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_='AreaContours'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AreaContours', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_ is not None:
            namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else ''
            self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', pretty_print=pretty_print)
        if self.value is not None:
            namespaceprefix_ = self.value_nsprefix_ + ':' if (UseCapturedNS_ and self.value_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%svalue>%s</%svalue>%s' % (namespaceprefix_ , self.gds_format_decimal(self.value, input_name='value'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
        elif nodeName_ == 'value' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'value')
            fval_ = self.gds_validate_decimal(fval_, node, 'value')
            self.value = fval_
            self.value_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.value)
# end class AreaContours


class AreaValue(GeneratedsSuper):
    """AreaValue -- З
    н
    а
    ч
    е
    н
    и
    е
    п
    л
    о
    щ
    а
    д
    и
    value -- З
    н
    а
    ч
    е
    н
    и
    е
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, value=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.value = value
        self.validate_PositiveDecimal(self.value)
        self.value_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AreaValue)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AreaValue.subclass:
            return AreaValue.subclass(*args_, **kwargs_)
        else:
            return AreaValue(*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_value(self):
        return self.value
    def set_value(self, value):
        self.value = value
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.value is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AreaValue', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AreaValue')
        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_ == 'AreaValue':
            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_='AreaValue')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AreaValue', 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_='AreaValue'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AreaValue', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.value is not None:
            namespaceprefix_ = self.value_nsprefix_ + ':' if (UseCapturedNS_ and self.value_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%svalue>%s</%svalue>%s' % (namespaceprefix_ , self.gds_format_decimal(self.value, input_name='value'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'value' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'value')
            fval_ = self.gds_validate_decimal(fval_, node, 'value')
            self.value = fval_
            self.value_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.value)
# end class AreaValue


class Area(GeneratedsSuper):
    """Area -- П
    л
    о
    щ
    а
    д
    ь
    ,
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    area -- П
    л
    о
    щ
    а
    д
    ь
    ,
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, area=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.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Area)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Area.subclass:
            return Area.subclass(*args_, **kwargs_)
        else:
            return Area(*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_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.area is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Area', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Area')
        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_ == 'Area':
            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_='Area')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Area', 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_='Area'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Area', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
# end class Area


class AreaQuarter(GeneratedsSuper):
    """AreaQuarter -- П
    л
    о
    щ
    а
    д
    ь
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    area -- П
    л
    о
    щ
    а
    д
    ь
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    unit -- Е
    д
    и
    н
    и
    ц
    а
    и
    з
    м
    е
    р
    е
    н
    и
    й
    -
    Г
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, area=None, unit=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.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.unit = unit
        self.unit_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AreaQuarter)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AreaQuarter.subclass:
            return AreaQuarter.subclass(*args_, **kwargs_)
        else:
            return AreaQuarter(*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_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_unit(self):
        return self.unit
    def set_unit(self, unit):
        self.unit = unit
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.area is not None or
            self.unit is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AreaQuarter', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AreaQuarter')
        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_ == 'AreaQuarter':
            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_='AreaQuarter')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AreaQuarter', 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_='AreaQuarter'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AreaQuarter', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.unit is not None:
            namespaceprefix_ = self.unit_nsprefix_ + ':' if (UseCapturedNS_ and self.unit_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sunit>%s</%sunit>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.unit), input_name='unit')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'unit':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'unit')
            value_ = self.gds_validate_string(value_, node, 'unit')
            self.unit = value_
            self.unit_nsprefix_ = child_.prefix
# end class AreaQuarter


class Name(GeneratedsSuper):
    """Name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, name=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.name = name
        self.name_nsprefix_ = None
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Name)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Name.subclass:
            return Name.subclass(*args_, **kwargs_)
        else:
            return Name(*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 has__content(self):
        if (
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Name', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Name')
        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_ == 'Name':
            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_='Name')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Name', 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_='Name'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Name', 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):
        pass
    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 Name


class AllowedUse(GeneratedsSuper):
    """AllowedUse -- Р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    permitted_use_established -- У
    с
    т
    а
    н
    о
    в
    л
    е
    н
    н
    о
    е
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, permitted_use_established=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.permitted_use_established = permitted_use_established
        self.permitted_use_established_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AllowedUse)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AllowedUse.subclass:
            return AllowedUse.subclass(*args_, **kwargs_)
        else:
            return AllowedUse(*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_permitted_use_established(self):
        return self.permitted_use_established
    def set_permitted_use_established(self, permitted_use_established):
        self.permitted_use_established = permitted_use_established
    def has__content(self):
        if (
            self.permitted_use_established is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AllowedUse', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AllowedUse')
        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_ == 'AllowedUse':
            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_='AllowedUse')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AllowedUse', 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_='AllowedUse'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AllowedUse', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.permitted_use_established is not None:
            namespaceprefix_ = self.permitted_use_established_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_use_established_nsprefix_) else ''
            self.permitted_use_established.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_use_established', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'permitted_use_established':
            obj_ = PermittedUseEstablished.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_use_established = obj_
            obj_.original_tagname_ = 'permitted_use_established'
# end class AllowedUse


class PermittedUseEstablished(GeneratedsSuper):
    """PermittedUseEstablished -- У
    с
    т
    а
    н
    о
    в
    л
    е
    н
    н
    о
    е
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    by_document -- П
    о
    д
    о
    к
    у
    м
    е
    н
    т
    у
    land_use -- В
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    р
    а
    н
    е
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    в
    ш
    и
    м
    с
    я
    к
    л
    а
    с
    с
    и
    ф
    и
    к
    а
    т
    о
    р
    о
    м
    land_use_mer -- В
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    к
    л
    а
    с
    с
    и
    ф
    и
    к
    а
    т
    о
    р
    о
    м
    ,
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    н
    ы
    м
    п
    р
    и
    к
    а
    з
    о
    м
    М
    и
    н
    э
    к
    о
    н
    о
    м
    р
    а
    з
    в
    и
    т
    и
    я
    Р
    о
    с
    с
    и
    и
    о
    т
    01.09.2014
    №
    540
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, by_document=None, land_use=None, land_use_mer=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.by_document = by_document
        self.by_document_nsprefix_ = None
        self.land_use = land_use
        self.land_use_nsprefix_ = None
        self.land_use_mer = land_use_mer
        self.land_use_mer_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PermittedUseEstablished)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PermittedUseEstablished.subclass:
            return PermittedUseEstablished.subclass(*args_, **kwargs_)
        else:
            return PermittedUseEstablished(*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_by_document(self):
        return self.by_document
    def set_by_document(self, by_document):
        self.by_document = by_document
    def get_land_use(self):
        return self.land_use
    def set_land_use(self, land_use):
        self.land_use = land_use
    def get_land_use_mer(self):
        return self.land_use_mer
    def set_land_use_mer(self, land_use_mer):
        self.land_use_mer = land_use_mer
    def has__content(self):
        if (
            self.by_document is not None or
            self.land_use is not None or
            self.land_use_mer is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedUseEstablished', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PermittedUseEstablished')
        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_ == 'PermittedUseEstablished':
            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_='PermittedUseEstablished')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PermittedUseEstablished', 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_='PermittedUseEstablished'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedUseEstablished', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.by_document is not None:
            namespaceprefix_ = self.by_document_nsprefix_ + ':' if (UseCapturedNS_ and self.by_document_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sby_document>%s</%sby_document>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.by_document), input_name='by_document')), namespaceprefix_ , eol_))
        if self.land_use is not None:
            namespaceprefix_ = self.land_use_nsprefix_ + ':' if (UseCapturedNS_ and self.land_use_nsprefix_) else ''
            self.land_use.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_use', pretty_print=pretty_print)
        if self.land_use_mer is not None:
            namespaceprefix_ = self.land_use_mer_nsprefix_ + ':' if (UseCapturedNS_ and self.land_use_mer_nsprefix_) else ''
            self.land_use_mer.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_use_mer', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'by_document':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'by_document')
            value_ = self.gds_validate_string(value_, node, 'by_document')
            self.by_document = value_
            self.by_document_nsprefix_ = child_.prefix
        elif nodeName_ == 'land_use':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_use = obj_
            obj_.original_tagname_ = 'land_use'
        elif nodeName_ == 'land_use_mer':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_use_mer = obj_
            obj_.original_tagname_ = 'land_use_mer'
# end class PermittedUseEstablished


class PermittedUses(GeneratedsSuper):
    """PermittedUses -- В
    и
    д
    (
    ы
    )
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    permitted_use -- В
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, permitted_use=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 permitted_use is None:
            self.permitted_use = []
        else:
            self.permitted_use = permitted_use
        self.permitted_use_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PermittedUses)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PermittedUses.subclass:
            return PermittedUses.subclass(*args_, **kwargs_)
        else:
            return PermittedUses(*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_permitted_use(self):
        return self.permitted_use
    def set_permitted_use(self, permitted_use):
        self.permitted_use = permitted_use
    def add_permitted_use(self, value):
        self.permitted_use.append(value)
    def insert_permitted_use_at(self, index, value):
        self.permitted_use.insert(index, value)
    def replace_permitted_use_at(self, index, value):
        self.permitted_use[index] = value
    def has__content(self):
        if (
            self.permitted_use
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedUses', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PermittedUses')
        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_ == 'PermittedUses':
            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_='PermittedUses')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PermittedUses', 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_='PermittedUses'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedUses', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for permitted_use_ in self.permitted_use:
            namespaceprefix_ = self.permitted_use_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_use_nsprefix_) else ''
            permitted_use_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_use', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'permitted_use':
            obj_ = PermittedUse.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_use.append(obj_)
            obj_.original_tagname_ = 'permitted_use'
# end class PermittedUses


class PermittedUse(GeneratedsSuper):
    """PermittedUse -- В
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    в
    и
    д
    а
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, 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.name = name
        self.name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PermittedUse)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PermittedUse.subclass:
            return PermittedUse.subclass(*args_, **kwargs_)
        else:
            return PermittedUse(*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 has__content(self):
        if (
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedUse', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PermittedUse')
        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_ == 'PermittedUse':
            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_='PermittedUse')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PermittedUse', 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_='PermittedUse'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedUse', 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):
        pass
    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 PermittedUse


class PermittesUsesGradReg(GeneratedsSuper):
    """PermittesUsesGradReg -- Р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    п
    о
    г
    р
    а
    д
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    н
    о
    м
    у
    р
    е
    г
    л
    а
    м
    е
    н
    т
    у
    reg_numb_border -- Р
    е
    е
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    г
    р
    а
    н
    и
    ц
    ы
    land_use -- В
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    к
    л
    а
    с
    с
    и
    ф
    и
    к
    а
    т
    о
    р
    о
    м
    ,
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    н
    ы
    м
    п
    р
    и
    к
    а
    з
    о
    м
    М
    и
    н
    э
    к
    о
    н
    о
    м
    р
    а
    з
    в
    и
    т
    и
    я
    Р
    о
    с
    с
    и
    и
    о
    т
    01.09.2014
    №
    540
    permitted_use_text -- Р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    (
    т
    е
    к
    с
    т
    о
    в
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, reg_numb_border=None, land_use=None, permitted_use_text=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.reg_numb_border = reg_numb_border
        self.validate_reg_numb_borderType(self.reg_numb_border)
        self.reg_numb_border_nsprefix_ = None
        self.land_use = land_use
        self.land_use_nsprefix_ = None
        self.permitted_use_text = permitted_use_text
        self.validate_MultiLiner(self.permitted_use_text)
        self.permitted_use_text_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PermittesUsesGradReg)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PermittesUsesGradReg.subclass:
            return PermittesUsesGradReg.subclass(*args_, **kwargs_)
        else:
            return PermittesUsesGradReg(*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_reg_numb_border(self):
        return self.reg_numb_border
    def set_reg_numb_border(self, reg_numb_border):
        self.reg_numb_border = reg_numb_border
    def get_land_use(self):
        return self.land_use
    def set_land_use(self, land_use):
        self.land_use = land_use
    def get_permitted_use_text(self):
        return self.permitted_use_text
    def set_permitted_use_text(self, permitted_use_text):
        self.permitted_use_text = permitted_use_text
    def validate_reg_numb_borderType(self, value):
        result = True
        # Validate type reg_numb_borderType, 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
            if len(value) > 50:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxLength restriction on reg_numb_borderType' % {"value" : encode_str_2_3(value), "lineno": lineno} )
                result = False
            if len(value) < 1:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minLength restriction on reg_numb_borderType' % {"value" : encode_str_2_3(value), "lineno": lineno} )
                result = False
        return result
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.reg_numb_border is not None or
            self.land_use is not None or
            self.permitted_use_text is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittesUsesGradReg', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PermittesUsesGradReg')
        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_ == 'PermittesUsesGradReg':
            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_='PermittesUsesGradReg')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PermittesUsesGradReg', 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_='PermittesUsesGradReg'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittesUsesGradReg', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.reg_numb_border is not None:
            namespaceprefix_ = self.reg_numb_border_nsprefix_ + ':' if (UseCapturedNS_ and self.reg_numb_border_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreg_numb_border>%s</%sreg_numb_border>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.reg_numb_border), input_name='reg_numb_border')), namespaceprefix_ , eol_))
        if self.land_use is not None:
            namespaceprefix_ = self.land_use_nsprefix_ + ':' if (UseCapturedNS_ and self.land_use_nsprefix_) else ''
            self.land_use.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_use', pretty_print=pretty_print)
        if self.permitted_use_text is not None:
            namespaceprefix_ = self.permitted_use_text_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_use_text_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spermitted_use_text>%s</%spermitted_use_text>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.permitted_use_text), input_name='permitted_use_text')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'reg_numb_border':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'reg_numb_border')
            value_ = self.gds_validate_string(value_, node, 'reg_numb_border')
            self.reg_numb_border = value_
            self.reg_numb_border_nsprefix_ = child_.prefix
            # validate type reg_numb_borderType
            self.validate_reg_numb_borderType(self.reg_numb_border)
        elif nodeName_ == 'land_use':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_use = obj_
            obj_.original_tagname_ = 'land_use'
        elif nodeName_ == 'permitted_use_text':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'permitted_use_text')
            value_ = self.gds_validate_string(value_, node, 'permitted_use_text')
            self.permitted_use_text = value_
            self.permitted_use_text_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.permitted_use_text)
# end class PermittesUsesGradReg


class CostInfo(GeneratedsSuper):
    """CostInfo -- З
    н
    а
    ч
    е
    н
    и
    е
    с
    т
    о
    и
    м
    о
    с
    т
    и
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    cost -- С
    т
    о
    и
    м
    о
    с
    т
    ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cost=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.cost = cost
        self.cost_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CostInfo)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CostInfo.subclass:
            return CostInfo.subclass(*args_, **kwargs_)
        else:
            return CostInfo(*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_cost(self):
        return self.cost
    def set_cost(self, cost):
        self.cost = cost
    def has__content(self):
        if (
            self.cost is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CostInfo', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CostInfo')
        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_ == 'CostInfo':
            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_='CostInfo')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CostInfo', 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_='CostInfo'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CostInfo', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.cost is not None:
            namespaceprefix_ = self.cost_nsprefix_ + ':' if (UseCapturedNS_ and self.cost_nsprefix_) else ''
            self.cost.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cost', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cost':
            obj_ = CostValue.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cost = obj_
            obj_.original_tagname_ = 'cost'
# end class CostInfo


class CostValue(GeneratedsSuper):
    """CostValue -- С
    т
    о
    и
    м
    о
    с
    т
    ь
    (
    р
    у
    б
    .)
    cost_value -- З
    н
    а
    ч
    е
    н
    и
    е
    с
    т
    о
    и
    м
    о
    с
    т
    и
    (
    р
    у
    б
    .)
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cost_value=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.cost_value = cost_value
        self.validate_PositiveDecimal(self.cost_value)
        self.cost_value_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CostValue)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CostValue.subclass:
            return CostValue.subclass(*args_, **kwargs_)
        else:
            return CostValue(*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_cost_value(self):
        return self.cost_value
    def set_cost_value(self, cost_value):
        self.cost_value = cost_value
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.cost_value is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CostValue', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CostValue')
        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_ == 'CostValue':
            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_='CostValue')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CostValue', 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_='CostValue'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CostValue', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.cost_value is not None:
            namespaceprefix_ = self.cost_value_nsprefix_ + ':' if (UseCapturedNS_ and self.cost_value_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scost_value>%s</%scost_value>%s' % (namespaceprefix_ , self.gds_format_decimal(self.cost_value, input_name='cost_value'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cost_value' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'cost_value')
            fval_ = self.gds_validate_decimal(fval_, node, 'cost_value')
            self.cost_value = fval_
            self.cost_value_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.cost_value)
# end class CostValue


class Cost(GeneratedsSuper):
    """Cost -- З
    н
    а
    ч
    е
    н
    и
    е
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    й
    с
    т
    о
    и
    м
    о
    с
    т
    и
    (
    р
    у
    б
    )
    value -- С
    т
    о
    и
    м
    о
    с
    т
    ь
    (
    р
    у
    б
    .)
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, value=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.value = value
        self.validate_PositiveDecimal(self.value)
        self.value_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Cost)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Cost.subclass:
            return Cost.subclass(*args_, **kwargs_)
        else:
            return Cost(*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_value(self):
        return self.value
    def set_value(self, value):
        self.value = value
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.value is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Cost', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Cost')
        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_ == 'Cost':
            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_='Cost')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Cost', 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_='Cost'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Cost', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.value is not None:
            namespaceprefix_ = self.value_nsprefix_ + ':' if (UseCapturedNS_ and self.value_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%svalue>%s</%svalue>%s' % (namespaceprefix_ , self.gds_format_decimal(self.value, input_name='value'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'value' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'value')
            fval_ = self.gds_validate_decimal(fval_, node, 'value')
            self.value = fval_
            self.value_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.value)
# end class Cost


class CostAllType(GeneratedsSuper):
    """CostAllType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    й
    с
    т
    о
    и
    м
    о
    с
    т
    и
    value -- К
    а
    д
    а
    с
    т
    р
    о
    в
    а
    я
    с
    т
    о
    и
    м
    о
    с
    т
    ь
    (
    р
    у
    б
    .)
    approvement_date -- Д
    а
    т
    а
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    и
    я
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    й
    с
    т
    о
    и
    м
    о
    с
    т
    и
    (
    д
    а
    т
    а
    в
    с
    т
    у
    п
    л
    е
    н
    и
    я
    в
    з
    а
    к
    о
    н
    н
    у
    ю
    с
    и
    determination_date -- Д
    а
    т
    а
    о
    п
    р
    е
    д
    е
    л
    е
    н
    и
    я
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    й
    с
    т
    о
    и
    м
    о
    с
    т
    и
    registration_date -- Д
    а
    т
    а
    в
    н
    е
    с
    е
    н
    и
    я
    с
    в
    е
    д
    е
    н
    и
    й
    о
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    й
    с
    т
    о
    и
    м
    о
    с
    т
    и
    в
    Е
    Г
    Р
    Н
    revisal_statement_date -- Д
    а
    т
    а
    п
    о
    д
    а
    ч
    и
    з
    а
    я
    в
    л
    е
    н
    и
    я
    о
    п
    е
    р
    е
    с
    м
    о
    т
    р
    е
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    й
    с
    т
    о
    и
    м
    о
    с
    т
    и
    application_date -- Д
    а
    т
    а
    н
    а
    ч
    а
    л
    а
    п
    р
    и
    м
    е
    н
    е
    н
    и
    я
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    й
    с
    т
    о
    и
    м
    о
    с
    т
    и
    approvement_document_number -- Н
    о
    м
    е
    р
    а
    к
    т
    а
    о
    б
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    и
    и
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    й
    с
    т
    о
    и
    м
    о
    с
    т
    и
    approvement_document_date -- Д
    а
    т
    а
    а
    к
    т
    а
    о
    б
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    и
    и
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    й
    с
    т
    о
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, value=None, approvement_date=None, determination_date=None, registration_date=None, revisal_statement_date=None, application_date=None, approvement_document_number=None, approvement_document_date=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.value = value
        self.value_nsprefix_ = None
        if isinstance(approvement_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(approvement_date, '%Y-%m-%d').date()
        else:
            initvalue_ = approvement_date
        self.approvement_date = initvalue_
        self.approvement_date_nsprefix_ = None
        if isinstance(determination_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(determination_date, '%Y-%m-%d').date()
        else:
            initvalue_ = determination_date
        self.determination_date = initvalue_
        self.determination_date_nsprefix_ = None
        if isinstance(registration_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(registration_date, '%Y-%m-%d').date()
        else:
            initvalue_ = registration_date
        self.registration_date = initvalue_
        self.registration_date_nsprefix_ = None
        if isinstance(revisal_statement_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(revisal_statement_date, '%Y-%m-%d').date()
        else:
            initvalue_ = revisal_statement_date
        self.revisal_statement_date = initvalue_
        self.revisal_statement_date_nsprefix_ = None
        if isinstance(application_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(application_date, '%Y-%m-%d').date()
        else:
            initvalue_ = application_date
        self.application_date = initvalue_
        self.application_date_nsprefix_ = None
        self.approvement_document_number = approvement_document_number
        self.approvement_document_number_nsprefix_ = None
        if isinstance(approvement_document_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(approvement_document_date, '%Y-%m-%d').date()
        else:
            initvalue_ = approvement_document_date
        self.approvement_document_date = initvalue_
        self.approvement_document_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CostAllType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CostAllType.subclass:
            return CostAllType.subclass(*args_, **kwargs_)
        else:
            return CostAllType(*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_value(self):
        return self.value
    def set_value(self, value):
        self.value = value
    def get_approvement_date(self):
        return self.approvement_date
    def set_approvement_date(self, approvement_date):
        self.approvement_date = approvement_date
    def get_determination_date(self):
        return self.determination_date
    def set_determination_date(self, determination_date):
        self.determination_date = determination_date
    def get_registration_date(self):
        return self.registration_date
    def set_registration_date(self, registration_date):
        self.registration_date = registration_date
    def get_revisal_statement_date(self):
        return self.revisal_statement_date
    def set_revisal_statement_date(self, revisal_statement_date):
        self.revisal_statement_date = revisal_statement_date
    def get_application_date(self):
        return self.application_date
    def set_application_date(self, application_date):
        self.application_date = application_date
    def get_approvement_document_number(self):
        return self.approvement_document_number
    def set_approvement_document_number(self, approvement_document_number):
        self.approvement_document_number = approvement_document_number
    def get_approvement_document_date(self):
        return self.approvement_document_date
    def set_approvement_document_date(self, approvement_document_date):
        self.approvement_document_date = approvement_document_date
    def has__content(self):
        if (
            self.value is not None or
            self.approvement_date is not None or
            self.determination_date is not None or
            self.registration_date is not None or
            self.revisal_statement_date is not None or
            self.application_date is not None or
            self.approvement_document_number is not None or
            self.approvement_document_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CostAllType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CostAllType')
        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_ == 'CostAllType':
            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_='CostAllType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CostAllType', 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_='CostAllType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CostAllType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.value is not None:
            namespaceprefix_ = self.value_nsprefix_ + ':' if (UseCapturedNS_ and self.value_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%svalue>%s</%svalue>%s' % (namespaceprefix_ , self.gds_format_decimal(self.value, input_name='value'), namespaceprefix_ , eol_))
        if self.approvement_date is not None:
            namespaceprefix_ = self.approvement_date_nsprefix_ + ':' if (UseCapturedNS_ and self.approvement_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sapprovement_date>%s</%sapprovement_date>%s' % (namespaceprefix_ , self.gds_format_date(self.approvement_date, input_name='approvement_date'), namespaceprefix_ , eol_))
        if self.determination_date is not None:
            namespaceprefix_ = self.determination_date_nsprefix_ + ':' if (UseCapturedNS_ and self.determination_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdetermination_date>%s</%sdetermination_date>%s' % (namespaceprefix_ , self.gds_format_date(self.determination_date, input_name='determination_date'), namespaceprefix_ , eol_))
        if self.registration_date is not None:
            namespaceprefix_ = self.registration_date_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_date>%s</%sregistration_date>%s' % (namespaceprefix_ , self.gds_format_date(self.registration_date, input_name='registration_date'), namespaceprefix_ , eol_))
        if self.revisal_statement_date is not None:
            namespaceprefix_ = self.revisal_statement_date_nsprefix_ + ':' if (UseCapturedNS_ and self.revisal_statement_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%srevisal_statement_date>%s</%srevisal_statement_date>%s' % (namespaceprefix_ , self.gds_format_date(self.revisal_statement_date, input_name='revisal_statement_date'), namespaceprefix_ , eol_))
        if self.application_date is not None:
            namespaceprefix_ = self.application_date_nsprefix_ + ':' if (UseCapturedNS_ and self.application_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sapplication_date>%s</%sapplication_date>%s' % (namespaceprefix_ , self.gds_format_date(self.application_date, input_name='application_date'), namespaceprefix_ , eol_))
        if self.approvement_document_number is not None:
            namespaceprefix_ = self.approvement_document_number_nsprefix_ + ':' if (UseCapturedNS_ and self.approvement_document_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sapprovement_document_number>%s</%sapprovement_document_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.approvement_document_number), input_name='approvement_document_number')), namespaceprefix_ , eol_))
        if self.approvement_document_date is not None:
            namespaceprefix_ = self.approvement_document_date_nsprefix_ + ':' if (UseCapturedNS_ and self.approvement_document_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sapprovement_document_date>%s</%sapprovement_document_date>%s' % (namespaceprefix_ , self.gds_format_date(self.approvement_document_date, input_name='approvement_document_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'value' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'value')
            fval_ = self.gds_validate_decimal(fval_, node, 'value')
            self.value = fval_
            self.value_nsprefix_ = child_.prefix
        elif nodeName_ == 'approvement_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.approvement_date = dval_
            self.approvement_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'determination_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.determination_date = dval_
            self.determination_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'registration_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.registration_date = dval_
            self.registration_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'revisal_statement_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.revisal_statement_date = dval_
            self.revisal_statement_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'application_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.application_date = dval_
            self.application_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'approvement_document_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'approvement_document_number')
            value_ = self.gds_validate_string(value_, node, 'approvement_document_number')
            self.approvement_document_number = value_
            self.approvement_document_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'approvement_document_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.approvement_document_date = dval_
            self.approvement_document_date_nsprefix_ = child_.prefix
# end class CostAllType


class CadWorks(GeneratedsSuper):
    """CadWorks -- С
    в
    е
    д
    е
    н
    и
    я
    о
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    м
    и
    н
    ж
    е
    н
    е
    р
    е
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    х
    и
    н
    ж
    е
    н
    е
    р
    а
    х
    )
    cad_work -- С
    в
    е
    д
    е
    н
    и
    я
    о
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    м
    и
    н
    ж
    е
    н
    е
    р
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cad_work=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 cad_work is None:
            self.cad_work = []
        else:
            self.cad_work = cad_work
        self.cad_work_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadWorks)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadWorks.subclass:
            return CadWorks.subclass(*args_, **kwargs_)
        else:
            return CadWorks(*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_cad_work(self):
        return self.cad_work
    def set_cad_work(self, cad_work):
        self.cad_work = cad_work
    def add_cad_work(self, value):
        self.cad_work.append(value)
    def insert_cad_work_at(self, index, value):
        self.cad_work.insert(index, value)
    def replace_cad_work_at(self, index, value):
        self.cad_work[index] = value
    def has__content(self):
        if (
            self.cad_work
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadWorks', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadWorks')
        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_ == 'CadWorks':
            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_='CadWorks')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadWorks', 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_='CadWorks'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadWorks', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for cad_work_ in self.cad_work:
            namespaceprefix_ = self.cad_work_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_work_nsprefix_) else ''
            cad_work_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cad_work', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cad_work':
            obj_ = CadWork.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cad_work.append(obj_)
            obj_.original_tagname_ = 'cad_work'
# end class CadWorks


class CadWork(GeneratedsSuper):
    """CadWork -- С
    в
    е
    д
    е
    н
    и
    я
    о
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    м
    и
    н
    ж
    е
    н
    е
    р
    е
    work_type -- В
    и
    д
    в
    ы
    п
    о
    л
    н
    е
    н
    н
    ы
    х
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    х
    р
    а
    б
    о
    т
    fio_cad_ingineer -- Ф
    а
    м
    и
    л
    и
    я
    И
    м
    я
    О
    т
    ч
    е
    с
    т
    в
    о
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    г
    о
    и
    н
    ж
    е
    н
    е
    р
    а
    cadastral_engineer_registry_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    в
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    м
    р
    е
    е
    с
    т
    р
    е
    л
    и
    ц
    ,
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    я
    ю
    щ
    и
    х
    к
    а
    д
    а
    с
    т
    р
    о
    в
    у
    ю
    д
    е
    я
    т
    е
    л
    ь
    н
    о
    с
    т
    ь
    cadastral_engineer_agreement -- Н
    о
    м
    е
    р
    з
    а
    к
    л
    ю
    ч
    е
    н
    и
    я
    д
    о
    г
    о
    в
    о
    р
    а
    н
    а
    в
    ы
    п
    о
    л
    н
    е
    н
    и
    е
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    х
    р
    а
    б
    о
    т
    cadastral_engineer_date -- Д
    а
    т
    а
    з
    а
    к
    л
    ю
    ч
    е
    н
    и
    я
    д
    о
    г
    о
    в
    о
    р
    а
    н
    а
    в
    ы
    п
    о
    л
    н
    е
    н
    и
    е
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    х
    р
    а
    б
    о
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, work_type=None, fio_cad_ingineer=None, cadastral_engineer_registry_number=None, cadastral_engineer_agreement=None, cadastral_engineer_date=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.work_type = work_type
        self.work_type_nsprefix_ = None
        self.fio_cad_ingineer = fio_cad_ingineer
        self.fio_cad_ingineer_nsprefix_ = None
        self.cadastral_engineer_registry_number = cadastral_engineer_registry_number
        self.cadastral_engineer_registry_number_nsprefix_ = None
        self.cadastral_engineer_agreement = cadastral_engineer_agreement
        self.cadastral_engineer_agreement_nsprefix_ = None
        if isinstance(cadastral_engineer_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(cadastral_engineer_date, '%Y-%m-%d').date()
        else:
            initvalue_ = cadastral_engineer_date
        self.cadastral_engineer_date = initvalue_
        self.cadastral_engineer_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadWork)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadWork.subclass:
            return CadWork.subclass(*args_, **kwargs_)
        else:
            return CadWork(*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_work_type(self):
        return self.work_type
    def set_work_type(self, work_type):
        self.work_type = work_type
    def get_fio_cad_ingineer(self):
        return self.fio_cad_ingineer
    def set_fio_cad_ingineer(self, fio_cad_ingineer):
        self.fio_cad_ingineer = fio_cad_ingineer
    def get_cadastral_engineer_registry_number(self):
        return self.cadastral_engineer_registry_number
    def set_cadastral_engineer_registry_number(self, cadastral_engineer_registry_number):
        self.cadastral_engineer_registry_number = cadastral_engineer_registry_number
    def get_cadastral_engineer_agreement(self):
        return self.cadastral_engineer_agreement
    def set_cadastral_engineer_agreement(self, cadastral_engineer_agreement):
        self.cadastral_engineer_agreement = cadastral_engineer_agreement
    def get_cadastral_engineer_date(self):
        return self.cadastral_engineer_date
    def set_cadastral_engineer_date(self, cadastral_engineer_date):
        self.cadastral_engineer_date = cadastral_engineer_date
    def has__content(self):
        if (
            self.work_type is not None or
            self.fio_cad_ingineer is not None or
            self.cadastral_engineer_registry_number is not None or
            self.cadastral_engineer_agreement is not None or
            self.cadastral_engineer_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadWork', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadWork')
        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_ == 'CadWork':
            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_='CadWork')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadWork', 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_='CadWork'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadWork', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.work_type is not None:
            namespaceprefix_ = self.work_type_nsprefix_ + ':' if (UseCapturedNS_ and self.work_type_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%swork_type>%s</%swork_type>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.work_type), input_name='work_type')), namespaceprefix_ , eol_))
        if self.fio_cad_ingineer is not None:
            namespaceprefix_ = self.fio_cad_ingineer_nsprefix_ + ':' if (UseCapturedNS_ and self.fio_cad_ingineer_nsprefix_) else ''
            self.fio_cad_ingineer.export(outfile, level, namespaceprefix_, namespacedef_='', name_='fio_cad_ingineer', pretty_print=pretty_print)
        if self.cadastral_engineer_registry_number is not None:
            namespaceprefix_ = self.cadastral_engineer_registry_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_engineer_registry_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scadastral_engineer_registry_number>%s</%scadastral_engineer_registry_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cadastral_engineer_registry_number), input_name='cadastral_engineer_registry_number')), namespaceprefix_ , eol_))
        if self.cadastral_engineer_agreement is not None:
            namespaceprefix_ = self.cadastral_engineer_agreement_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_engineer_agreement_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scadastral_engineer_agreement>%s</%scadastral_engineer_agreement>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cadastral_engineer_agreement), input_name='cadastral_engineer_agreement')), namespaceprefix_ , eol_))
        if self.cadastral_engineer_date is not None:
            namespaceprefix_ = self.cadastral_engineer_date_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_engineer_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scadastral_engineer_date>%s</%scadastral_engineer_date>%s' % (namespaceprefix_ , self.gds_format_date(self.cadastral_engineer_date, input_name='cadastral_engineer_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'work_type':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'work_type')
            value_ = self.gds_validate_string(value_, node, 'work_type')
            self.work_type = value_
            self.work_type_nsprefix_ = child_.prefix
        elif nodeName_ == 'fio_cad_ingineer':
            obj_ = Fio.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.fio_cad_ingineer = obj_
            obj_.original_tagname_ = 'fio_cad_ingineer'
        elif nodeName_ == 'cadastral_engineer_registry_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cadastral_engineer_registry_number')
            value_ = self.gds_validate_string(value_, node, 'cadastral_engineer_registry_number')
            self.cadastral_engineer_registry_number = value_
            self.cadastral_engineer_registry_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'cadastral_engineer_agreement':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cadastral_engineer_agreement')
            value_ = self.gds_validate_string(value_, node, 'cadastral_engineer_agreement')
            self.cadastral_engineer_agreement = value_
            self.cadastral_engineer_agreement_nsprefix_ = child_.prefix
        elif nodeName_ == 'cadastral_engineer_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.cadastral_engineer_date = dval_
            self.cadastral_engineer_date_nsprefix_ = child_.prefix
# end class CadWork


class CadWorksOut(GeneratedsSuper):
    """CadWorksOut -- С
    в
    е
    д
    е
    н
    и
    я
    о
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    х
    р
    а
    б
    о
    т
    а
    х
    cad_work -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    р
    а
    б
    о
    т
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cad_work=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 cad_work is None:
            self.cad_work = []
        else:
            self.cad_work = cad_work
        self.cad_work_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadWorksOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadWorksOut.subclass:
            return CadWorksOut.subclass(*args_, **kwargs_)
        else:
            return CadWorksOut(*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_cad_work(self):
        return self.cad_work
    def set_cad_work(self, cad_work):
        self.cad_work = cad_work
    def add_cad_work(self, value):
        self.cad_work.append(value)
    def insert_cad_work_at(self, index, value):
        self.cad_work.insert(index, value)
    def replace_cad_work_at(self, index, value):
        self.cad_work[index] = value
    def has__content(self):
        if (
            self.cad_work
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadWorksOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadWorksOut')
        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_ == 'CadWorksOut':
            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_='CadWorksOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadWorksOut', 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_='CadWorksOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadWorksOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for cad_work_ in self.cad_work:
            namespaceprefix_ = self.cad_work_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_work_nsprefix_) else ''
            cad_work_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cad_work', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cad_work':
            obj_ = CadWorkOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cad_work.append(obj_)
            obj_.original_tagname_ = 'cad_work'
# end class CadWorksOut


class CadWorkOut(GeneratedsSuper):
    """CadWorkOut -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    р
    а
    б
    о
    т
    ы
    cadastral_engineer_registry_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    в
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    м
    р
    е
    е
    с
    т
    р
    е
    л
    и
    ц
    ,
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    я
    ю
    щ
    и
    х
    к
    а
    д
    а
    с
    т
    р
    о
    в
    у
    ю
    д
    е
    я
    т
    е
    л
    ь
    н
    о
    с
    т
    ь
    work_type -- В
    и
    д
    в
    ы
    п
    о
    л
    н
    е
    н
    н
    ы
    х
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    х
    р
    а
    б
    о
    т
    cadastral_engineer_agreement -- Н
    о
    м
    е
    р
    з
    а
    к
    л
    ю
    ч
    е
    н
    и
    я
    д
    о
    г
    о
    в
    о
    р
    а
    н
    а
    в
    ы
    п
    о
    л
    н
    е
    н
    и
    е
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    х
    р
    а
    б
    о
    т
    cadastral_engineer_date -- Д
    а
    т
    а
    з
    а
    к
    л
    ю
    ч
    е
    н
    и
    я
    д
    о
    г
    о
    в
    о
    р
    а
    н
    а
    в
    ы
    п
    о
    л
    н
    е
    н
    и
    е
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    х
    р
    а
    б
    о
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cadastral_engineer_registry_number=None, work_type=None, cadastral_engineer_agreement=None, cadastral_engineer_date=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.cadastral_engineer_registry_number = cadastral_engineer_registry_number
        self.cadastral_engineer_registry_number_nsprefix_ = None
        self.work_type = work_type
        self.work_type_nsprefix_ = None
        self.cadastral_engineer_agreement = cadastral_engineer_agreement
        self.cadastral_engineer_agreement_nsprefix_ = None
        if isinstance(cadastral_engineer_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(cadastral_engineer_date, '%Y-%m-%d').date()
        else:
            initvalue_ = cadastral_engineer_date
        self.cadastral_engineer_date = initvalue_
        self.cadastral_engineer_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadWorkOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadWorkOut.subclass:
            return CadWorkOut.subclass(*args_, **kwargs_)
        else:
            return CadWorkOut(*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_cadastral_engineer_registry_number(self):
        return self.cadastral_engineer_registry_number
    def set_cadastral_engineer_registry_number(self, cadastral_engineer_registry_number):
        self.cadastral_engineer_registry_number = cadastral_engineer_registry_number
    def get_work_type(self):
        return self.work_type
    def set_work_type(self, work_type):
        self.work_type = work_type
    def get_cadastral_engineer_agreement(self):
        return self.cadastral_engineer_agreement
    def set_cadastral_engineer_agreement(self, cadastral_engineer_agreement):
        self.cadastral_engineer_agreement = cadastral_engineer_agreement
    def get_cadastral_engineer_date(self):
        return self.cadastral_engineer_date
    def set_cadastral_engineer_date(self, cadastral_engineer_date):
        self.cadastral_engineer_date = cadastral_engineer_date
    def has__content(self):
        if (
            self.cadastral_engineer_registry_number is not None or
            self.work_type is not None or
            self.cadastral_engineer_agreement is not None or
            self.cadastral_engineer_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadWorkOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadWorkOut')
        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_ == 'CadWorkOut':
            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_='CadWorkOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadWorkOut', 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_='CadWorkOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadWorkOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.cadastral_engineer_registry_number is not None:
            namespaceprefix_ = self.cadastral_engineer_registry_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_engineer_registry_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scadastral_engineer_registry_number>%s</%scadastral_engineer_registry_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cadastral_engineer_registry_number), input_name='cadastral_engineer_registry_number')), namespaceprefix_ , eol_))
        if self.work_type is not None:
            namespaceprefix_ = self.work_type_nsprefix_ + ':' if (UseCapturedNS_ and self.work_type_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%swork_type>%s</%swork_type>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.work_type), input_name='work_type')), namespaceprefix_ , eol_))
        if self.cadastral_engineer_agreement is not None:
            namespaceprefix_ = self.cadastral_engineer_agreement_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_engineer_agreement_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scadastral_engineer_agreement>%s</%scadastral_engineer_agreement>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cadastral_engineer_agreement), input_name='cadastral_engineer_agreement')), namespaceprefix_ , eol_))
        if self.cadastral_engineer_date is not None:
            namespaceprefix_ = self.cadastral_engineer_date_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_engineer_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scadastral_engineer_date>%s</%scadastral_engineer_date>%s' % (namespaceprefix_ , self.gds_format_date(self.cadastral_engineer_date, input_name='cadastral_engineer_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cadastral_engineer_registry_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cadastral_engineer_registry_number')
            value_ = self.gds_validate_string(value_, node, 'cadastral_engineer_registry_number')
            self.cadastral_engineer_registry_number = value_
            self.cadastral_engineer_registry_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'work_type':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'work_type')
            value_ = self.gds_validate_string(value_, node, 'work_type')
            self.work_type = value_
            self.work_type_nsprefix_ = child_.prefix
        elif nodeName_ == 'cadastral_engineer_agreement':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cadastral_engineer_agreement')
            value_ = self.gds_validate_string(value_, node, 'cadastral_engineer_agreement')
            self.cadastral_engineer_agreement = value_
            self.cadastral_engineer_agreement_nsprefix_ = child_.prefix
        elif nodeName_ == 'cadastral_engineer_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.cadastral_engineer_date = dval_
            self.cadastral_engineer_date_nsprefix_ = child_.prefix
# end class CadWorkOut


class DataObjectLand(GeneratedsSuper):
    """DataObjectLand -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    -
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    а
    д
    р
    е
    с
    п
    о
    л
    н
    ы
    й
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, address_location=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.object = object
        self.object_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DataObjectLand)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DataObjectLand.subclass:
            return DataObjectLand.subclass(*args_, **kwargs_)
        else:
            return DataObjectLand(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def has__content(self):
        if (
            self.object is not None or
            self.address_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectLand', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DataObjectLand')
        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_ == 'DataObjectLand':
            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_='DataObjectLand')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DataObjectLand', 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_='DataObjectLand'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectLand', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationLand.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
# end class DataObjectLand


class ObjectLand(GeneratedsSuper):
    """ObjectLand -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    )
    common_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    subtype -- В
    и
    д
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    date_removed_cad_account -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    н
    а
    о
    с
    н
    о
    в
    а
    н
    и
    и
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    ,
    и
    л
    и
    и
    з
    з
    е
    м
    е
    л
    ь
    и
    л
    и
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ,
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    а
    я
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    ь
    н
    а
    к
    о
    т
    о
    р
    ы
    е
    н
    е
    р
    а
    з
    г
    р
    а
    н
    и
    ч
    е
    н
    а
    )
    reg_date_by_doc -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    п
    о
    д
    о
    к
    у
    м
    е
    н
    т
    у
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, common_data=None, subtype=None, date_removed_cad_account=None, reg_date_by_doc=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.common_data = common_data
        self.common_data_nsprefix_ = None
        self.subtype = subtype
        self.subtype_nsprefix_ = None
        self.date_removed_cad_account = date_removed_cad_account
        self.date_removed_cad_account_nsprefix_ = None
        if isinstance(reg_date_by_doc, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(reg_date_by_doc, '%Y-%m-%d').date()
        else:
            initvalue_ = reg_date_by_doc
        self.reg_date_by_doc = initvalue_
        self.reg_date_by_doc_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectLand)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectLand.subclass:
            return ObjectLand.subclass(*args_, **kwargs_)
        else:
            return ObjectLand(*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_common_data(self):
        return self.common_data
    def set_common_data(self, common_data):
        self.common_data = common_data
    def get_subtype(self):
        return self.subtype
    def set_subtype(self, subtype):
        self.subtype = subtype
    def get_date_removed_cad_account(self):
        return self.date_removed_cad_account
    def set_date_removed_cad_account(self, date_removed_cad_account):
        self.date_removed_cad_account = date_removed_cad_account
    def get_reg_date_by_doc(self):
        return self.reg_date_by_doc
    def set_reg_date_by_doc(self, reg_date_by_doc):
        self.reg_date_by_doc = reg_date_by_doc
    def has__content(self):
        if (
            self.common_data is not None or
            self.subtype is not None or
            self.date_removed_cad_account is not None or
            self.reg_date_by_doc is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectLand', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectLand')
        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_ == 'ObjectLand':
            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_='ObjectLand')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectLand', 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_='ObjectLand'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectLand', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.common_data is not None:
            namespaceprefix_ = self.common_data_nsprefix_ + ':' if (UseCapturedNS_ and self.common_data_nsprefix_) else ''
            self.common_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_data', pretty_print=pretty_print)
        if self.subtype is not None:
            namespaceprefix_ = self.subtype_nsprefix_ + ':' if (UseCapturedNS_ and self.subtype_nsprefix_) else ''
            self.subtype.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subtype', pretty_print=pretty_print)
        if self.date_removed_cad_account is not None:
            namespaceprefix_ = self.date_removed_cad_account_nsprefix_ + ':' if (UseCapturedNS_ and self.date_removed_cad_account_nsprefix_) else ''
            self.date_removed_cad_account.export(outfile, level, namespaceprefix_, namespacedef_='', name_='date_removed_cad_account', pretty_print=pretty_print)
        if self.reg_date_by_doc is not None:
            namespaceprefix_ = self.reg_date_by_doc_nsprefix_ + ':' if (UseCapturedNS_ and self.reg_date_by_doc_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreg_date_by_doc>%s</%sreg_date_by_doc>%s' % (namespaceprefix_ , self.gds_format_date(self.reg_date_by_doc, input_name='reg_date_by_doc'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'common_data':
            obj_ = CommonData.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_data = obj_
            obj_.original_tagname_ = 'common_data'
        elif nodeName_ == 'subtype':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.subtype = obj_
            obj_.original_tagname_ = 'subtype'
        elif nodeName_ == 'date_removed_cad_account':
            obj_ = FormLandWithdrawalAndNotDifferenntiated.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.date_removed_cad_account = obj_
            obj_.original_tagname_ = 'date_removed_cad_account'
        elif nodeName_ == 'reg_date_by_doc':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.reg_date_by_doc = dval_
            self.reg_date_by_doc_nsprefix_ = child_.prefix
# end class ObjectLand


class ObjectLandAndWithdrawal(GeneratedsSuper):
    """ObjectLandAndWithdrawal -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    ) (
    и
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    )
    common_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    subtype -- В
    и
    д
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    date_removed_cad_account -- С
    в
    е
    д
    е
    н
    и
    я
    о
    н
    а
    л
    и
    ч
    и
    и
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    reg_date_by_doc -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    п
    о
    д
    о
    к
    у
    м
    е
    н
    т
    у
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, common_data=None, subtype=None, date_removed_cad_account=None, reg_date_by_doc=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.common_data = common_data
        self.common_data_nsprefix_ = None
        self.subtype = subtype
        self.subtype_nsprefix_ = None
        self.date_removed_cad_account = date_removed_cad_account
        self.date_removed_cad_account_nsprefix_ = None
        if isinstance(reg_date_by_doc, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(reg_date_by_doc, '%Y-%m-%d').date()
        else:
            initvalue_ = reg_date_by_doc
        self.reg_date_by_doc = initvalue_
        self.reg_date_by_doc_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectLandAndWithdrawal)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectLandAndWithdrawal.subclass:
            return ObjectLandAndWithdrawal.subclass(*args_, **kwargs_)
        else:
            return ObjectLandAndWithdrawal(*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_common_data(self):
        return self.common_data
    def set_common_data(self, common_data):
        self.common_data = common_data
    def get_subtype(self):
        return self.subtype
    def set_subtype(self, subtype):
        self.subtype = subtype
    def get_date_removed_cad_account(self):
        return self.date_removed_cad_account
    def set_date_removed_cad_account(self, date_removed_cad_account):
        self.date_removed_cad_account = date_removed_cad_account
    def get_reg_date_by_doc(self):
        return self.reg_date_by_doc
    def set_reg_date_by_doc(self, reg_date_by_doc):
        self.reg_date_by_doc = reg_date_by_doc
    def has__content(self):
        if (
            self.common_data is not None or
            self.subtype is not None or
            self.date_removed_cad_account is not None or
            self.reg_date_by_doc is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectLandAndWithdrawal', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectLandAndWithdrawal')
        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_ == 'ObjectLandAndWithdrawal':
            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_='ObjectLandAndWithdrawal')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectLandAndWithdrawal', 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_='ObjectLandAndWithdrawal'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectLandAndWithdrawal', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.common_data is not None:
            namespaceprefix_ = self.common_data_nsprefix_ + ':' if (UseCapturedNS_ and self.common_data_nsprefix_) else ''
            self.common_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_data', pretty_print=pretty_print)
        if self.subtype is not None:
            namespaceprefix_ = self.subtype_nsprefix_ + ':' if (UseCapturedNS_ and self.subtype_nsprefix_) else ''
            self.subtype.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subtype', pretty_print=pretty_print)
        if self.date_removed_cad_account is not None:
            namespaceprefix_ = self.date_removed_cad_account_nsprefix_ + ':' if (UseCapturedNS_ and self.date_removed_cad_account_nsprefix_) else ''
            self.date_removed_cad_account.export(outfile, level, namespaceprefix_, namespacedef_='', name_='date_removed_cad_account', pretty_print=pretty_print)
        if self.reg_date_by_doc is not None:
            namespaceprefix_ = self.reg_date_by_doc_nsprefix_ + ':' if (UseCapturedNS_ and self.reg_date_by_doc_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreg_date_by_doc>%s</%sreg_date_by_doc>%s' % (namespaceprefix_ , self.gds_format_date(self.reg_date_by_doc, input_name='reg_date_by_doc'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'common_data':
            obj_ = CommonData.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_data = obj_
            obj_.original_tagname_ = 'common_data'
        elif nodeName_ == 'subtype':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.subtype = obj_
            obj_.original_tagname_ = 'subtype'
        elif nodeName_ == 'date_removed_cad_account':
            obj_ = DateRemovedCadAccount.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.date_removed_cad_account = obj_
            obj_.original_tagname_ = 'date_removed_cad_account'
        elif nodeName_ == 'reg_date_by_doc':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.reg_date_by_doc = dval_
            self.reg_date_by_doc_nsprefix_ = child_.prefix
# end class ObjectLandAndWithdrawal


class ParamsLandCategoryUses(GeneratedsSuper):
    """ParamsLandCategoryUses -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    п
    л
    о
    щ
    а
    д
    ь
    ,
    к
    а
    т
    е
    г
    о
    р
    и
    я
    ,
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    )
    category -- К
    а
    т
    е
    г
    о
    р
    и
    я
    permitted_use -- Р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
      
    * permittes_uses_grad_reg -- Р
      а
      з
      р
      е
      ш
      е
      н
      н
      о
      е
      и
      с
      п
      о
      л
      ь
      з
      о
      в
      а
      н
      и
      е
      п
      о
      г
      р
      а
      д
      о
      с
      т
      р
      о
      и
      т
      е
      л
      ь
      н
      о
      м
      у
      р
      е
      г
      л
      а
      м
      е
      н
      т
      у
    * area -- П
      л
      о
      щ
      а
      д
      ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, category=None, permitted_use=None, permittes_uses_grad_reg=None, area=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.category = category
        self.category_nsprefix_ = None
        self.permitted_use = permitted_use
        self.permitted_use_nsprefix_ = None
        self.permittes_uses_grad_reg = permittes_uses_grad_reg
        self.permittes_uses_grad_reg_nsprefix_ = None
        self.area = area
        self.area_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsLandCategoryUses)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsLandCategoryUses.subclass:
            return ParamsLandCategoryUses.subclass(*args_, **kwargs_)
        else:
            return ParamsLandCategoryUses(*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_category(self):
        return self.category
    def set_category(self, category):
        self.category = category
    def get_permitted_use(self):
        return self.permitted_use
    def set_permitted_use(self, permitted_use):
        self.permitted_use = permitted_use
    def get_permittes_uses_grad_reg(self):
        return self.permittes_uses_grad_reg
    def set_permittes_uses_grad_reg(self, permittes_uses_grad_reg):
        self.permittes_uses_grad_reg = permittes_uses_grad_reg
    def get_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def has__content(self):
        if (
            self.category is not None or
            self.permitted_use is not None or
            self.permittes_uses_grad_reg is not None or
            self.area is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsLandCategoryUses', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsLandCategoryUses')
        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_ == 'ParamsLandCategoryUses':
            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_='ParamsLandCategoryUses')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsLandCategoryUses', 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_='ParamsLandCategoryUses'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsLandCategoryUses', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.category is not None:
            namespaceprefix_ = self.category_nsprefix_ + ':' if (UseCapturedNS_ and self.category_nsprefix_) else ''
            self.category.export(outfile, level, namespaceprefix_, namespacedef_='', name_='category', pretty_print=pretty_print)
        if self.permitted_use is not None:
            namespaceprefix_ = self.permitted_use_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_use_nsprefix_) else ''
            self.permitted_use.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_use', pretty_print=pretty_print)
        if self.permittes_uses_grad_reg is not None:
            namespaceprefix_ = self.permittes_uses_grad_reg_nsprefix_ + ':' if (UseCapturedNS_ and self.permittes_uses_grad_reg_nsprefix_) else ''
            self.permittes_uses_grad_reg.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permittes_uses_grad_reg', pretty_print=pretty_print)
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            self.area.export(outfile, level, namespaceprefix_, namespacedef_='', name_='area', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'category':
            obj_ = categoryType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.category = obj_
            obj_.original_tagname_ = 'category'
        elif nodeName_ == 'permitted_use':
            obj_ = AllowedUse.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_use = obj_
            obj_.original_tagname_ = 'permitted_use'
        elif nodeName_ == 'permittes_uses_grad_reg':
            obj_ = PermittesUsesGradReg.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permittes_uses_grad_reg = obj_
            obj_.original_tagname_ = 'permittes_uses_grad_reg'
        elif nodeName_ == 'area':
            obj_ = LandArea.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.area = obj_
            obj_.original_tagname_ = 'area'
# end class ParamsLandCategoryUses


class ParamsLandUses(GeneratedsSuper):
    """ParamsLandUses -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    п
    л
    о
    щ
    а
    д
    ь
    ,
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    )
    area -- П
    л
    о
    щ
    а
    д
    ь
    permitted_use -- Р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    permittes_uses_grad_reg -- Р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    п
    о
    г
    р
    а
    д
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    н
    о
    м
    у
    р
    е
    г
    л
    а
    м
    е
    н
    т
    у
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, area=None, permitted_use=None, permittes_uses_grad_reg=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.area = area
        self.area_nsprefix_ = None
        self.permitted_use = permitted_use
        self.permitted_use_nsprefix_ = None
        self.permittes_uses_grad_reg = permittes_uses_grad_reg
        self.permittes_uses_grad_reg_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsLandUses)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsLandUses.subclass:
            return ParamsLandUses.subclass(*args_, **kwargs_)
        else:
            return ParamsLandUses(*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_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_permitted_use(self):
        return self.permitted_use
    def set_permitted_use(self, permitted_use):
        self.permitted_use = permitted_use
    def get_permittes_uses_grad_reg(self):
        return self.permittes_uses_grad_reg
    def set_permittes_uses_grad_reg(self, permittes_uses_grad_reg):
        self.permittes_uses_grad_reg = permittes_uses_grad_reg
    def has__content(self):
        if (
            self.area is not None or
            self.permitted_use is not None or
            self.permittes_uses_grad_reg is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsLandUses', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsLandUses')
        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_ == 'ParamsLandUses':
            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_='ParamsLandUses')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsLandUses', 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_='ParamsLandUses'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsLandUses', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            self.area.export(outfile, level, namespaceprefix_, namespacedef_='', name_='area', pretty_print=pretty_print)
        if self.permitted_use is not None:
            namespaceprefix_ = self.permitted_use_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_use_nsprefix_) else ''
            self.permitted_use.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_use', pretty_print=pretty_print)
        if self.permittes_uses_grad_reg is not None:
            namespaceprefix_ = self.permittes_uses_grad_reg_nsprefix_ + ':' if (UseCapturedNS_ and self.permittes_uses_grad_reg_nsprefix_) else ''
            self.permittes_uses_grad_reg.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permittes_uses_grad_reg', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'area':
            obj_ = LandArea.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.area = obj_
            obj_.original_tagname_ = 'area'
        elif nodeName_ == 'permitted_use':
            obj_ = AllowedUse.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_use = obj_
            obj_.original_tagname_ = 'permitted_use'
        elif nodeName_ == 'permittes_uses_grad_reg':
            obj_ = PermittesUsesGradReg.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permittes_uses_grad_reg = obj_
            obj_.original_tagname_ = 'permittes_uses_grad_reg'
# end class ParamsLandUses


class LandRecord(GeneratedsSuper):
    """LandRecord -- З
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    restrict_records -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, address_location=None, right_record=None, restrict_records=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
        self.right_record = right_record
        self.right_record_nsprefix_ = None
        self.restrict_records = restrict_records
        self.restrict_records_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LandRecord)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LandRecord.subclass:
            return LandRecord.subclass(*args_, **kwargs_)
        else:
            return LandRecord(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def get_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def get_restrict_records(self):
        return self.restrict_records
    def set_restrict_records(self, restrict_records):
        self.restrict_records = restrict_records
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.address_location is not None or
            self.right_record is not None or
            self.restrict_records is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandRecord', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LandRecord')
        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_ == 'LandRecord':
            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_='LandRecord')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LandRecord', 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_='LandRecord'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandRecord', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', pretty_print=pretty_print)
        if self.right_record is not None:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            self.right_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', pretty_print=pretty_print)
        if self.restrict_records is not None:
            namespaceprefix_ = self.restrict_records_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_records_nsprefix_) else ''
            self.restrict_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_records', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = ParamsLandUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationLand.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
        elif nodeName_ == 'right_record':
            obj_ = RightRecordIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record = obj_
            obj_.original_tagname_ = 'right_record'
        elif nodeName_ == 'restrict_records':
            obj_ = RestrictRecordsIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_records = obj_
            obj_.original_tagname_ = 'restrict_records'
# end class LandRecord


class BuildRecord(GeneratedsSuper):
    """BuildRecord -- З
    д
    а
    н
    и
    е
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    з
    д
    а
    н
    и
    я
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    restrict_records -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, address_location=None, right_record=None, restrict_records=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
        self.right_record = right_record
        self.right_record_nsprefix_ = None
        self.restrict_records = restrict_records
        self.restrict_records_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BuildRecord)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BuildRecord.subclass:
            return BuildRecord.subclass(*args_, **kwargs_)
        else:
            return BuildRecord(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def get_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def get_restrict_records(self):
        return self.restrict_records
    def set_restrict_records(self, restrict_records):
        self.restrict_records = restrict_records
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.address_location is not None or
            self.right_record is not None or
            self.restrict_records is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuildRecord', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BuildRecord')
        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_ == 'BuildRecord':
            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_='BuildRecord')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BuildRecord', 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_='BuildRecord'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuildRecord', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', pretty_print=pretty_print)
        if self.right_record is not None:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            self.right_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', pretty_print=pretty_print)
        if self.restrict_records is not None:
            namespaceprefix_ = self.restrict_records_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_records_nsprefix_) else ''
            self.restrict_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_records', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = ParamsBuildPurposeUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationBuild.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
        elif nodeName_ == 'right_record':
            obj_ = RightRecordIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record = obj_
            obj_.original_tagname_ = 'right_record'
        elif nodeName_ == 'restrict_records':
            obj_ = RestrictRecordsIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_records = obj_
            obj_.original_tagname_ = 'restrict_records'
# end class BuildRecord


class DataObjectBuild(GeneratedsSuper):
    """DataObjectBuild -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    -
    з
    д
    а
    н
    и
    и
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    а
    д
    р
    е
    с
    п
    о
    л
    н
    ы
    й
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, address_location=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.object = object
        self.object_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DataObjectBuild)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DataObjectBuild.subclass:
            return DataObjectBuild.subclass(*args_, **kwargs_)
        else:
            return DataObjectBuild(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def has__content(self):
        if (
            self.object is not None or
            self.address_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectBuild', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DataObjectBuild')
        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_ == 'DataObjectBuild':
            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_='DataObjectBuild')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DataObjectBuild', 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_='DataObjectBuild'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectBuild', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationBuild.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
# end class DataObjectBuild


class ParamsBuildAboutType(GeneratedsSuper):
    """ParamsBuildAboutType -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    з
    д
    а
    н
    и
    я
    (
    с
    м
    а
    т
    е
    р
    и
    а
    л
    о
    м
    н
    а
    р
    у
    ж
    н
    ы
    х
    с
    т
    е
    н
    )
    area -- П
    л
    о
    щ
    а
    д
    ь
    ,
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    materials -- М
    а
    т
    е
    р
    и
    а
    л
    ы
    н
    а
    р
    у
    ж
    н
    ы
    х
    с
    т
    е
    н
    з
    д
    а
    н
    и
    я
    floors -- К
    о
    л
    и
    ч
    е
    с
    т
    в
    о
    э
    т
    а
    ж
    е
    й
    (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    п
    о
    д
    з
    е
    м
    н
    ы
    х
    )
    underground_floors -- К
    о
    л
    и
    ч
    е
    с
    т
    в
    о
    п
    о
    д
    з
    е
    м
    н
    ы
    х
    э
    т
    а
    ж
    е
    й
    purpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    з
    д
    а
    н
    и
    я
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    з
    д
    а
    н
    и
    я
    year_built -- Г
    о
    д
    з
    а
    в
    е
    р
    ш
    е
    н
    и
    я
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    year_commisioning -- Г
    о
    д
    в
    в
    о
    д
    а
    в
    э
    к
    с
    п
    л
    у
    а
    т
    а
    ц
    и
    ю
    п
    о
    з
    а
    в
    е
    р
    ш
    е
    н
    и
    и
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    permitted_uses -- В
    и
    д
    (
    ы
    )
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, area=None, materials=None, floors=None, underground_floors=None, purpose=None, name=None, year_built=None, year_commisioning=None, permitted_uses=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.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.materials = materials
        self.materials_nsprefix_ = None
        self.floors = floors
        self.floors_nsprefix_ = None
        self.underground_floors = underground_floors
        self.underground_floors_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
        self.name = name
        self.validate_MultiLiner(self.name)
        self.name_nsprefix_ = None
        self.year_built = year_built
        self.year_built_nsprefix_ = None
        self.year_commisioning = year_commisioning
        self.year_commisioning_nsprefix_ = None
        self.permitted_uses = permitted_uses
        self.permitted_uses_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsBuildAboutType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsBuildAboutType.subclass:
            return ParamsBuildAboutType.subclass(*args_, **kwargs_)
        else:
            return ParamsBuildAboutType(*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_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_materials(self):
        return self.materials
    def set_materials(self, materials):
        self.materials = materials
    def get_floors(self):
        return self.floors
    def set_floors(self, floors):
        self.floors = floors
    def get_underground_floors(self):
        return self.underground_floors
    def set_underground_floors(self, underground_floors):
        self.underground_floors = underground_floors
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_year_built(self):
        return self.year_built
    def set_year_built(self, year_built):
        self.year_built = year_built
    def get_year_commisioning(self):
        return self.year_commisioning
    def set_year_commisioning(self, year_commisioning):
        self.year_commisioning = year_commisioning
    def get_permitted_uses(self):
        return self.permitted_uses
    def set_permitted_uses(self, permitted_uses):
        self.permitted_uses = permitted_uses
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.area is not None or
            self.materials is not None or
            self.floors is not None or
            self.underground_floors is not None or
            self.purpose is not None or
            self.name is not None or
            self.year_built is not None or
            self.year_commisioning is not None or
            self.permitted_uses is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsBuildAboutType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsBuildAboutType')
        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_ == 'ParamsBuildAboutType':
            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_='ParamsBuildAboutType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsBuildAboutType', 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_='ParamsBuildAboutType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsBuildAboutType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.materials is not None:
            namespaceprefix_ = self.materials_nsprefix_ + ':' if (UseCapturedNS_ and self.materials_nsprefix_) else ''
            self.materials.export(outfile, level, namespaceprefix_, namespacedef_='', name_='materials', pretty_print=pretty_print)
        if self.floors is not None:
            namespaceprefix_ = self.floors_nsprefix_ + ':' if (UseCapturedNS_ and self.floors_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfloors>%s</%sfloors>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.floors), input_name='floors')), namespaceprefix_ , eol_))
        if self.underground_floors is not None:
            namespaceprefix_ = self.underground_floors_nsprefix_ + ':' if (UseCapturedNS_ and self.underground_floors_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sunderground_floors>%s</%sunderground_floors>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.underground_floors), input_name='underground_floors')), namespaceprefix_ , eol_))
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            self.purpose.export(outfile, level, namespaceprefix_, namespacedef_='', name_='purpose', pretty_print=pretty_print)
        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.year_built is not None:
            namespaceprefix_ = self.year_built_nsprefix_ + ':' if (UseCapturedNS_ and self.year_built_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%syear_built>%s</%syear_built>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.year_built), input_name='year_built')), namespaceprefix_ , eol_))
        if self.year_commisioning is not None:
            namespaceprefix_ = self.year_commisioning_nsprefix_ + ':' if (UseCapturedNS_ and self.year_commisioning_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%syear_commisioning>%s</%syear_commisioning>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.year_commisioning), input_name='year_commisioning')), namespaceprefix_ , eol_))
        if self.permitted_uses is not None:
            namespaceprefix_ = self.permitted_uses_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_uses_nsprefix_) else ''
            self.permitted_uses.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_uses', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'materials':
            obj_ = Materials.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.materials = obj_
            obj_.original_tagname_ = 'materials'
        elif nodeName_ == 'floors':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'floors')
            value_ = self.gds_validate_string(value_, node, 'floors')
            self.floors = value_
            self.floors_nsprefix_ = child_.prefix
        elif nodeName_ == 'underground_floors':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'underground_floors')
            value_ = self.gds_validate_string(value_, node, 'underground_floors')
            self.underground_floors = value_
            self.underground_floors_nsprefix_ = child_.prefix
        elif nodeName_ == 'purpose':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.purpose = obj_
            obj_.original_tagname_ = 'purpose'
        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
            # validate type MultiLiner
            self.validate_MultiLiner(self.name)
        elif nodeName_ == 'year_built':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'year_built')
            value_ = self.gds_validate_string(value_, node, 'year_built')
            self.year_built = value_
            self.year_built_nsprefix_ = child_.prefix
        elif nodeName_ == 'year_commisioning':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'year_commisioning')
            value_ = self.gds_validate_string(value_, node, 'year_commisioning')
            self.year_commisioning = value_
            self.year_commisioning_nsprefix_ = child_.prefix
        elif nodeName_ == 'permitted_uses':
            obj_ = PermittedUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_uses = obj_
            obj_.original_tagname_ = 'permitted_uses'
# end class ParamsBuildAboutType


class ParamsBuildWithoutMaterials(GeneratedsSuper):
    """ParamsBuildWithoutMaterials -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    з
    д
    а
    н
    и
    я
    (
    б
    е
    з
    м
    е
    т
    е
    р
    и
    а
    л
    а
    с
    т
    е
    н
    )
    area -- П
    л
    о
    щ
    а
    д
    ь
    ,
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    floors -- К
    о
    л
    и
    ч
    е
    с
    т
    в
    о
    э
    т
    а
    ж
    е
    й
    (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    п
    о
    д
    з
    е
    м
    н
    ы
    х
    )
    underground_floors -- К
    о
    л
    и
    ч
    е
    с
    т
    в
    о
    п
    о
    д
    з
    е
    м
    н
    ы
    х
    э
    т
    а
    ж
    е
    й
    purpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    з
    д
    а
    н
    и
    я
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    з
    д
    а
    н
    и
    я
    year_built -- Г
    о
    д
    з
    а
    в
    е
    р
    ш
    е
    н
    и
    я
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    year_commisioning -- Г
    о
    д
    в
    в
    о
    д
    а
    в
    э
    к
    с
    п
    л
    у
    а
    т
    а
    ц
    и
    ю
    п
    о
    з
    а
    в
    е
    р
    ш
    е
    н
    и
    и
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    permitted_uses -- В
    и
    д
    (
    ы
    )
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, area=None, floors=None, underground_floors=None, purpose=None, name=None, year_built=None, year_commisioning=None, permitted_uses=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.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.floors = floors
        self.floors_nsprefix_ = None
        self.underground_floors = underground_floors
        self.underground_floors_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
        self.name = name
        self.validate_MultiLiner(self.name)
        self.name_nsprefix_ = None
        self.year_built = year_built
        self.year_built_nsprefix_ = None
        self.year_commisioning = year_commisioning
        self.year_commisioning_nsprefix_ = None
        self.permitted_uses = permitted_uses
        self.permitted_uses_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsBuildWithoutMaterials)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsBuildWithoutMaterials.subclass:
            return ParamsBuildWithoutMaterials.subclass(*args_, **kwargs_)
        else:
            return ParamsBuildWithoutMaterials(*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_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_floors(self):
        return self.floors
    def set_floors(self, floors):
        self.floors = floors
    def get_underground_floors(self):
        return self.underground_floors
    def set_underground_floors(self, underground_floors):
        self.underground_floors = underground_floors
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_year_built(self):
        return self.year_built
    def set_year_built(self, year_built):
        self.year_built = year_built
    def get_year_commisioning(self):
        return self.year_commisioning
    def set_year_commisioning(self, year_commisioning):
        self.year_commisioning = year_commisioning
    def get_permitted_uses(self):
        return self.permitted_uses
    def set_permitted_uses(self, permitted_uses):
        self.permitted_uses = permitted_uses
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.area is not None or
            self.floors is not None or
            self.underground_floors is not None or
            self.purpose is not None or
            self.name is not None or
            self.year_built is not None or
            self.year_commisioning is not None or
            self.permitted_uses is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsBuildWithoutMaterials', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsBuildWithoutMaterials')
        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_ == 'ParamsBuildWithoutMaterials':
            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_='ParamsBuildWithoutMaterials')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsBuildWithoutMaterials', 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_='ParamsBuildWithoutMaterials'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsBuildWithoutMaterials', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.floors is not None:
            namespaceprefix_ = self.floors_nsprefix_ + ':' if (UseCapturedNS_ and self.floors_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfloors>%s</%sfloors>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.floors), input_name='floors')), namespaceprefix_ , eol_))
        if self.underground_floors is not None:
            namespaceprefix_ = self.underground_floors_nsprefix_ + ':' if (UseCapturedNS_ and self.underground_floors_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sunderground_floors>%s</%sunderground_floors>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.underground_floors), input_name='underground_floors')), namespaceprefix_ , eol_))
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            self.purpose.export(outfile, level, namespaceprefix_, namespacedef_='', name_='purpose', pretty_print=pretty_print)
        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.year_built is not None:
            namespaceprefix_ = self.year_built_nsprefix_ + ':' if (UseCapturedNS_ and self.year_built_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%syear_built>%s</%syear_built>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.year_built), input_name='year_built')), namespaceprefix_ , eol_))
        if self.year_commisioning is not None:
            namespaceprefix_ = self.year_commisioning_nsprefix_ + ':' if (UseCapturedNS_ and self.year_commisioning_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%syear_commisioning>%s</%syear_commisioning>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.year_commisioning), input_name='year_commisioning')), namespaceprefix_ , eol_))
        if self.permitted_uses is not None:
            namespaceprefix_ = self.permitted_uses_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_uses_nsprefix_) else ''
            self.permitted_uses.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_uses', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'floors':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'floors')
            value_ = self.gds_validate_string(value_, node, 'floors')
            self.floors = value_
            self.floors_nsprefix_ = child_.prefix
        elif nodeName_ == 'underground_floors':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'underground_floors')
            value_ = self.gds_validate_string(value_, node, 'underground_floors')
            self.underground_floors = value_
            self.underground_floors_nsprefix_ = child_.prefix
        elif nodeName_ == 'purpose':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.purpose = obj_
            obj_.original_tagname_ = 'purpose'
        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
            # validate type MultiLiner
            self.validate_MultiLiner(self.name)
        elif nodeName_ == 'year_built':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'year_built')
            value_ = self.gds_validate_string(value_, node, 'year_built')
            self.year_built = value_
            self.year_built_nsprefix_ = child_.prefix
        elif nodeName_ == 'year_commisioning':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'year_commisioning')
            value_ = self.gds_validate_string(value_, node, 'year_commisioning')
            self.year_commisioning = value_
            self.year_commisioning_nsprefix_ = child_.prefix
        elif nodeName_ == 'permitted_uses':
            obj_ = PermittedUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_uses = obj_
            obj_.original_tagname_ = 'permitted_uses'
# end class ParamsBuildWithoutMaterials


class ParamsBuildPurposeUses(GeneratedsSuper):
    """ParamsBuildPurposeUses -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    з
    д
    а
    н
    и
    я
    (
    п
    л
    о
    щ
    а
    д
    ь
    ,
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    ,
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    )
    area -- П
    л
    о
    щ
    а
    д
    ь
    ,
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    purpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    з
    д
    а
    н
    и
    я
    permitted_uses -- В
    и
    д
    (
    ы
    )
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, area=None, purpose=None, permitted_uses=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.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
        self.permitted_uses = permitted_uses
        self.permitted_uses_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsBuildPurposeUses)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsBuildPurposeUses.subclass:
            return ParamsBuildPurposeUses.subclass(*args_, **kwargs_)
        else:
            return ParamsBuildPurposeUses(*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_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def get_permitted_uses(self):
        return self.permitted_uses
    def set_permitted_uses(self, permitted_uses):
        self.permitted_uses = permitted_uses
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.area is not None or
            self.purpose is not None or
            self.permitted_uses is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsBuildPurposeUses', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsBuildPurposeUses')
        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_ == 'ParamsBuildPurposeUses':
            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_='ParamsBuildPurposeUses')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsBuildPurposeUses', 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_='ParamsBuildPurposeUses'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsBuildPurposeUses', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            self.purpose.export(outfile, level, namespaceprefix_, namespacedef_='', name_='purpose', pretty_print=pretty_print)
        if self.permitted_uses is not None:
            namespaceprefix_ = self.permitted_uses_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_uses_nsprefix_) else ''
            self.permitted_uses.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_uses', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'purpose':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.purpose = obj_
            obj_.original_tagname_ = 'purpose'
        elif nodeName_ == 'permitted_uses':
            obj_ = PermittedUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_uses = obj_
            obj_.original_tagname_ = 'permitted_uses'
# end class ParamsBuildPurposeUses


class RoomRecord(GeneratedsSuper):
    """RoomRecord -- П
    о
    м
    е
    щ
    е
    н
    и
    е
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    address_room -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    restrict_records -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, address_room=None, right_record=None, restrict_records=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_room = address_room
        self.address_room_nsprefix_ = None
        self.right_record = right_record
        self.right_record_nsprefix_ = None
        self.restrict_records = restrict_records
        self.restrict_records_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomRecord)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomRecord.subclass:
            return RoomRecord.subclass(*args_, **kwargs_)
        else:
            return RoomRecord(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_room(self):
        return self.address_room
    def set_address_room(self, address_room):
        self.address_room = address_room
    def get_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def get_restrict_records(self):
        return self.restrict_records
    def set_restrict_records(self, restrict_records):
        self.restrict_records = restrict_records
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.address_room is not None or
            self.right_record is not None or
            self.restrict_records is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomRecord', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomRecord')
        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_ == 'RoomRecord':
            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_='RoomRecord')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomRecord', 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_='RoomRecord'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomRecord', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_room is not None:
            namespaceprefix_ = self.address_room_nsprefix_ + ':' if (UseCapturedNS_ and self.address_room_nsprefix_) else ''
            self.address_room.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_room', pretty_print=pretty_print)
        if self.right_record is not None:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            self.right_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', pretty_print=pretty_print)
        if self.restrict_records is not None:
            namespaceprefix_ = self.restrict_records_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_records_nsprefix_) else ''
            self.restrict_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_records', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = ParamsRoomBaseWithoutName.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_room':
            obj_ = AddressLocationRoom.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_room = obj_
            obj_.original_tagname_ = 'address_room'
        elif nodeName_ == 'right_record':
            obj_ = RightRecordIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record = obj_
            obj_.original_tagname_ = 'right_record'
        elif nodeName_ == 'restrict_records':
            obj_ = RestrictRecordsIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_records = obj_
            obj_.original_tagname_ = 'restrict_records'
# end class RoomRecord


class DataObjectRoom(GeneratedsSuper):
    """DataObjectRoom -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    -
    п
    о
    м
    е
    щ
    е
    н
    и
    и
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    а
    д
    р
    е
    с
    п
    о
    л
    н
    ы
    й
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    address_room -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, address_room=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.object = object
        self.object_nsprefix_ = None
        self.address_room = address_room
        self.address_room_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DataObjectRoom)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DataObjectRoom.subclass:
            return DataObjectRoom.subclass(*args_, **kwargs_)
        else:
            return DataObjectRoom(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_address_room(self):
        return self.address_room
    def set_address_room(self, address_room):
        self.address_room = address_room
    def has__content(self):
        if (
            self.object is not None or
            self.address_room is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectRoom', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DataObjectRoom')
        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_ == 'DataObjectRoom':
            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_='DataObjectRoom')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DataObjectRoom', 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_='DataObjectRoom'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectRoom', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.address_room is not None:
            namespaceprefix_ = self.address_room_nsprefix_ + ':' if (UseCapturedNS_ and self.address_room_nsprefix_) else ''
            self.address_room.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_room', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'address_room':
            obj_ = AddressLocationRoom.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_room = obj_
            obj_.original_tagname_ = 'address_room'
# end class DataObjectRoom


class ParamsRoomBase(GeneratedsSuper):
    """ParamsRoomBase -- О
    с
    н
    о
    в
    н
    ы
    е
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    area -- П
    л
    о
    щ
    а
    д
    ь
    ,
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    permitted_uses -- В
    и
    д
    (
    ы
    )
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    purpose --
    Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    type -- В
    и
    д
    ж
    и
    л
    о
    г
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    common_property -- О
    б
    щ
    е
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    о
    в
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    в
    м
    н
    о
    г
    о
    к
    в
    а
    р
    т
    и
    р
    н
    о
    м
    д
    о
    м
    е
    service -- И
    м
    у
    щ
    е
    с
    т
    в
    о
    о
    б
    щ
    е
    г
    о
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    special_type -- В
    и
    д
    ж
    и
    л
    о
    г
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    с
    п
    е
    ц
    и
    а
    л
    и
    з
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    ж
    и
    л
    и
    щ
    н
    о
    г
    о
    ф
    о
    н
    д
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, area=None, permitted_uses=None, name=None, purpose=None, type_=None, common_property=None, service=None, special_type=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.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.permitted_uses = permitted_uses
        self.permitted_uses_nsprefix_ = None
        self.name = name
        self.validate_MultiLiner(self.name)
        self.name_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
        self.type_ = type_
        self.type__nsprefix_ = None
        self.common_property = common_property
        self.common_property_nsprefix_ = None
        self.service = service
        self.service_nsprefix_ = None
        self.special_type = special_type
        self.special_type_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsRoomBase)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsRoomBase.subclass:
            return ParamsRoomBase.subclass(*args_, **kwargs_)
        else:
            return ParamsRoomBase(*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_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_permitted_uses(self):
        return self.permitted_uses
    def set_permitted_uses(self, permitted_uses):
        self.permitted_uses = permitted_uses
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def get_type(self):
        return self.type_
    def set_type(self, type_):
        self.type_ = type_
    def get_common_property(self):
        return self.common_property
    def set_common_property(self, common_property):
        self.common_property = common_property
    def get_service(self):
        return self.service
    def set_service(self, service):
        self.service = service
    def get_special_type(self):
        return self.special_type
    def set_special_type(self, special_type):
        self.special_type = special_type
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.area is not None or
            self.permitted_uses is not None or
            self.name is not None or
            self.purpose is not None or
            self.type_ is not None or
            self.common_property is not None or
            self.service is not None or
            self.special_type is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsRoomBase', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsRoomBase')
        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_ == 'ParamsRoomBase':
            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_='ParamsRoomBase')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsRoomBase', 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_='ParamsRoomBase'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsRoomBase', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.permitted_uses is not None:
            namespaceprefix_ = self.permitted_uses_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_uses_nsprefix_) else ''
            self.permitted_uses.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_uses', pretty_print=pretty_print)
        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.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            self.purpose.export(outfile, level, namespaceprefix_, namespacedef_='', name_='purpose', pretty_print=pretty_print)
        if self.type_ is not None:
            namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else ''
            self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', pretty_print=pretty_print)
        if self.common_property is not None:
            namespaceprefix_ = self.common_property_nsprefix_ + ':' if (UseCapturedNS_ and self.common_property_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scommon_property>%s</%scommon_property>%s' % (namespaceprefix_ , self.gds_format_boolean(self.common_property, input_name='common_property'), namespaceprefix_ , eol_))
        if self.service is not None:
            namespaceprefix_ = self.service_nsprefix_ + ':' if (UseCapturedNS_ and self.service_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sservice>%s</%sservice>%s' % (namespaceprefix_ , self.gds_format_boolean(self.service, input_name='service'), namespaceprefix_ , eol_))
        if self.special_type is not None:
            namespaceprefix_ = self.special_type_nsprefix_ + ':' if (UseCapturedNS_ and self.special_type_nsprefix_) else ''
            self.special_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='special_type', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'permitted_uses':
            obj_ = PermittedUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_uses = obj_
            obj_.original_tagname_ = 'permitted_uses'
        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
            # validate type MultiLiner
            self.validate_MultiLiner(self.name)
        elif nodeName_ == 'purpose':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.purpose = obj_
            obj_.original_tagname_ = 'purpose'
        elif nodeName_ == 'type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
        elif nodeName_ == 'common_property':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'common_property')
            ival_ = self.gds_validate_boolean(ival_, node, 'common_property')
            self.common_property = ival_
            self.common_property_nsprefix_ = child_.prefix
        elif nodeName_ == 'service':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'service')
            ival_ = self.gds_validate_boolean(ival_, node, 'service')
            self.service = ival_
            self.service_nsprefix_ = child_.prefix
        elif nodeName_ == 'special_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.special_type = obj_
            obj_.original_tagname_ = 'special_type'
# end class ParamsRoomBase


class ParamsRoomBaseWithoutName(GeneratedsSuper):
    """ParamsRoomBaseWithoutName -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    (
    з
    а
    и
    с
    к
    л
    ю
    ч
    е
    н
    и
    е
    м
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    я
    )
    area -- П
    л
    о
    щ
    а
    д
    ь
    ,
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    permitted_uses -- В
    и
    д
    (
    ы
    )
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    purpose --
    Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    type -- В
    и
    д
    ж
    и
    л
    о
    г
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    common_property -- О
    б
    щ
    е
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    о
    в
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    в
    м
    н
    о
    г
    о
    к
    в
    а
    р
    т
    и
    р
    н
    о
    м
    д
    о
    м
    е
    service -- И
    м
    у
    щ
    е
    с
    т
    в
    о
    о
    б
    щ
    е
    г
    о
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    special_type -- В
    и
    д
    ж
    и
    л
    о
    г
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    с
    п
    е
    ц
    и
    а
    л
    и
    з
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    ж
    и
    л
    и
    щ
    н
    о
    г
    о
    ф
    о
    н
    д
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, area=None, permitted_uses=None, purpose=None, type_=None, common_property=None, service=None, special_type=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.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.permitted_uses = permitted_uses
        self.permitted_uses_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
        self.type_ = type_
        self.type__nsprefix_ = None
        self.common_property = common_property
        self.common_property_nsprefix_ = None
        self.service = service
        self.service_nsprefix_ = None
        self.special_type = special_type
        self.special_type_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsRoomBaseWithoutName)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsRoomBaseWithoutName.subclass:
            return ParamsRoomBaseWithoutName.subclass(*args_, **kwargs_)
        else:
            return ParamsRoomBaseWithoutName(*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_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_permitted_uses(self):
        return self.permitted_uses
    def set_permitted_uses(self, permitted_uses):
        self.permitted_uses = permitted_uses
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def get_type(self):
        return self.type_
    def set_type(self, type_):
        self.type_ = type_
    def get_common_property(self):
        return self.common_property
    def set_common_property(self, common_property):
        self.common_property = common_property
    def get_service(self):
        return self.service
    def set_service(self, service):
        self.service = service
    def get_special_type(self):
        return self.special_type
    def set_special_type(self, special_type):
        self.special_type = special_type
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.area is not None or
            self.permitted_uses is not None or
            self.purpose is not None or
            self.type_ is not None or
            self.common_property is not None or
            self.service is not None or
            self.special_type is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsRoomBaseWithoutName', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsRoomBaseWithoutName')
        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_ == 'ParamsRoomBaseWithoutName':
            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_='ParamsRoomBaseWithoutName')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsRoomBaseWithoutName', 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_='ParamsRoomBaseWithoutName'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsRoomBaseWithoutName', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.permitted_uses is not None:
            namespaceprefix_ = self.permitted_uses_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_uses_nsprefix_) else ''
            self.permitted_uses.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_uses', pretty_print=pretty_print)
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            self.purpose.export(outfile, level, namespaceprefix_, namespacedef_='', name_='purpose', pretty_print=pretty_print)
        if self.type_ is not None:
            namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else ''
            self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', pretty_print=pretty_print)
        if self.common_property is not None:
            namespaceprefix_ = self.common_property_nsprefix_ + ':' if (UseCapturedNS_ and self.common_property_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scommon_property>%s</%scommon_property>%s' % (namespaceprefix_ , self.gds_format_boolean(self.common_property, input_name='common_property'), namespaceprefix_ , eol_))
        if self.service is not None:
            namespaceprefix_ = self.service_nsprefix_ + ':' if (UseCapturedNS_ and self.service_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sservice>%s</%sservice>%s' % (namespaceprefix_ , self.gds_format_boolean(self.service, input_name='service'), namespaceprefix_ , eol_))
        if self.special_type is not None:
            namespaceprefix_ = self.special_type_nsprefix_ + ':' if (UseCapturedNS_ and self.special_type_nsprefix_) else ''
            self.special_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='special_type', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'permitted_uses':
            obj_ = PermittedUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_uses = obj_
            obj_.original_tagname_ = 'permitted_uses'
        elif nodeName_ == 'purpose':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.purpose = obj_
            obj_.original_tagname_ = 'purpose'
        elif nodeName_ == 'type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
        elif nodeName_ == 'common_property':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'common_property')
            ival_ = self.gds_validate_boolean(ival_, node, 'common_property')
            self.common_property = ival_
            self.common_property_nsprefix_ = child_.prefix
        elif nodeName_ == 'service':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'service')
            ival_ = self.gds_validate_boolean(ival_, node, 'service')
            self.service = ival_
            self.service_nsprefix_ = child_.prefix
        elif nodeName_ == 'special_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.special_type = obj_
            obj_.original_tagname_ = 'special_type'
# end class ParamsRoomBaseWithoutName


class ParamsRoomObject(GeneratedsSuper):
    """ParamsRoomObject -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    в
    з
    д
    а
    н
    и
    и
    ,
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    и
    room_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, room_record=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 room_record is None:
            self.room_record = []
        else:
            self.room_record = room_record
        self.room_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsRoomObject)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsRoomObject.subclass:
            return ParamsRoomObject.subclass(*args_, **kwargs_)
        else:
            return ParamsRoomObject(*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_room_record(self):
        return self.room_record
    def set_room_record(self, room_record):
        self.room_record = room_record
    def add_room_record(self, value):
        self.room_record.append(value)
    def insert_room_record_at(self, index, value):
        self.room_record.insert(index, value)
    def replace_room_record_at(self, index, value):
        self.room_record[index] = value
    def has__content(self):
        if (
            self.room_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsRoomObject', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsRoomObject')
        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_ == 'ParamsRoomObject':
            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_='ParamsRoomObject')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsRoomObject', 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_='ParamsRoomObject'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsRoomObject', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for room_record_ in self.room_record:
            namespaceprefix_ = self.room_record_nsprefix_ + ':' if (UseCapturedNS_ and self.room_record_nsprefix_) else ''
            room_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'room_record':
            obj_ = room_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_record.append(obj_)
            obj_.original_tagname_ = 'room_record'
# end class ParamsRoomObject


class ParamsRoomWithoutSpecialType(GeneratedsSuper):
    """ParamsRoomWithoutSpecialType -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    (
    б
    е
    з
    в
    и
    д
    а
    ж
    и
    л
    о
    г
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    с
    п
    е
    ц
    и
    а
    л
    и
    з
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    ж
    и
    л
    и
    щ
    н
    о
    г
    о
    ф
    о
    н
    д
    а
    )
    area -- П
    л
    о
    щ
    а
    д
    ь
    ,
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    permitted_uses -- В
    и
    д
    (
    ы
    )
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    purpose --
    Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    type -- В
    и
    д
    ж
    и
    л
    о
    г
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    common_property -- О
    б
    щ
    е
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    о
    в
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    в
    м
    н
    о
    г
    о
    к
    в
    а
    р
    т
    и
    р
    н
    о
    м
    д
    о
    м
    е
    service -- И
    м
    у
    щ
    е
    с
    т
    в
    о
    о
    б
    щ
    е
    г
    о
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, area=None, permitted_uses=None, purpose=None, type_=None, common_property=None, service=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.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.permitted_uses = permitted_uses
        self.permitted_uses_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
        self.type_ = type_
        self.type__nsprefix_ = None
        self.common_property = common_property
        self.common_property_nsprefix_ = None
        self.service = service
        self.service_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsRoomWithoutSpecialType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsRoomWithoutSpecialType.subclass:
            return ParamsRoomWithoutSpecialType.subclass(*args_, **kwargs_)
        else:
            return ParamsRoomWithoutSpecialType(*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_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_permitted_uses(self):
        return self.permitted_uses
    def set_permitted_uses(self, permitted_uses):
        self.permitted_uses = permitted_uses
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def get_type(self):
        return self.type_
    def set_type(self, type_):
        self.type_ = type_
    def get_common_property(self):
        return self.common_property
    def set_common_property(self, common_property):
        self.common_property = common_property
    def get_service(self):
        return self.service
    def set_service(self, service):
        self.service = service
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.area is not None or
            self.permitted_uses is not None or
            self.purpose is not None or
            self.type_ is not None or
            self.common_property is not None or
            self.service is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsRoomWithoutSpecialType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsRoomWithoutSpecialType')
        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_ == 'ParamsRoomWithoutSpecialType':
            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_='ParamsRoomWithoutSpecialType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsRoomWithoutSpecialType', 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_='ParamsRoomWithoutSpecialType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsRoomWithoutSpecialType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.permitted_uses is not None:
            namespaceprefix_ = self.permitted_uses_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_uses_nsprefix_) else ''
            self.permitted_uses.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_uses', pretty_print=pretty_print)
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            self.purpose.export(outfile, level, namespaceprefix_, namespacedef_='', name_='purpose', pretty_print=pretty_print)
        if self.type_ is not None:
            namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else ''
            self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', pretty_print=pretty_print)
        if self.common_property is not None:
            namespaceprefix_ = self.common_property_nsprefix_ + ':' if (UseCapturedNS_ and self.common_property_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scommon_property>%s</%scommon_property>%s' % (namespaceprefix_ , self.gds_format_boolean(self.common_property, input_name='common_property'), namespaceprefix_ , eol_))
        if self.service is not None:
            namespaceprefix_ = self.service_nsprefix_ + ':' if (UseCapturedNS_ and self.service_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sservice>%s</%sservice>%s' % (namespaceprefix_ , self.gds_format_boolean(self.service, input_name='service'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'permitted_uses':
            obj_ = PermittedUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_uses = obj_
            obj_.original_tagname_ = 'permitted_uses'
        elif nodeName_ == 'purpose':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.purpose = obj_
            obj_.original_tagname_ = 'purpose'
        elif nodeName_ == 'type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
        elif nodeName_ == 'common_property':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'common_property')
            ival_ = self.gds_validate_boolean(ival_, node, 'common_property')
            self.common_property = ival_
            self.common_property_nsprefix_ = child_.prefix
        elif nodeName_ == 'service':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'service')
            ival_ = self.gds_validate_boolean(ival_, node, 'service')
            self.service = ival_
            self.service_nsprefix_ = child_.prefix
# end class ParamsRoomWithoutSpecialType


class CarParkingSpaceRecord(GeneratedsSuper):
    """CarParkingSpaceRecord -- М
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    address_room -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    restrict_records -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, address_room=None, right_record=None, restrict_records=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_room = address_room
        self.address_room_nsprefix_ = None
        self.right_record = right_record
        self.right_record_nsprefix_ = None
        self.restrict_records = restrict_records
        self.restrict_records_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CarParkingSpaceRecord)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CarParkingSpaceRecord.subclass:
            return CarParkingSpaceRecord.subclass(*args_, **kwargs_)
        else:
            return CarParkingSpaceRecord(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_room(self):
        return self.address_room
    def set_address_room(self, address_room):
        self.address_room = address_room
    def get_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def get_restrict_records(self):
        return self.restrict_records
    def set_restrict_records(self, restrict_records):
        self.restrict_records = restrict_records
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.address_room is not None or
            self.right_record is not None or
            self.restrict_records is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CarParkingSpaceRecord', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CarParkingSpaceRecord')
        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_ == 'CarParkingSpaceRecord':
            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_='CarParkingSpaceRecord')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CarParkingSpaceRecord', 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_='CarParkingSpaceRecord'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CarParkingSpaceRecord', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_room is not None:
            namespaceprefix_ = self.address_room_nsprefix_ + ':' if (UseCapturedNS_ and self.address_room_nsprefix_) else ''
            self.address_room.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_room', pretty_print=pretty_print)
        if self.right_record is not None:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            self.right_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', pretty_print=pretty_print)
        if self.restrict_records is not None:
            namespaceprefix_ = self.restrict_records_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_records_nsprefix_) else ''
            self.restrict_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_records', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = Area.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_room':
            obj_ = AddressLocationCarParkingSpace.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_room = obj_
            obj_.original_tagname_ = 'address_room'
        elif nodeName_ == 'right_record':
            obj_ = RightRecordIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record = obj_
            obj_.original_tagname_ = 'right_record'
        elif nodeName_ == 'restrict_records':
            obj_ = RestrictRecordsIndividNoPart.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_records = obj_
            obj_.original_tagname_ = 'restrict_records'
# end class CarParkingSpaceRecord


class DataObjectCarParkingSpace(GeneratedsSuper):
    """DataObjectCarParkingSpace -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    -
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    е
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    а
    д
    р
    е
    с
    п
    о
    л
    н
    ы
    й
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    address_room -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, address_room=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.object = object
        self.object_nsprefix_ = None
        self.address_room = address_room
        self.address_room_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DataObjectCarParkingSpace)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DataObjectCarParkingSpace.subclass:
            return DataObjectCarParkingSpace.subclass(*args_, **kwargs_)
        else:
            return DataObjectCarParkingSpace(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_address_room(self):
        return self.address_room
    def set_address_room(self, address_room):
        self.address_room = address_room
    def has__content(self):
        if (
            self.object is not None or
            self.address_room is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectCarParkingSpace', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DataObjectCarParkingSpace')
        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_ == 'DataObjectCarParkingSpace':
            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_='DataObjectCarParkingSpace')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DataObjectCarParkingSpace', 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_='DataObjectCarParkingSpace'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectCarParkingSpace', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.address_room is not None:
            namespaceprefix_ = self.address_room_nsprefix_ + ':' if (UseCapturedNS_ and self.address_room_nsprefix_) else ''
            self.address_room.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_room', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'address_room':
            obj_ = AddressLocationCarParkingSpace.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_room = obj_
            obj_.original_tagname_ = 'address_room'
# end class DataObjectCarParkingSpace


class ParamsCarParkingSpaceObject(GeneratedsSuper):
    """ParamsCarParkingSpaceObject -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    в
    з
    д
    а
    н
    и
    и
    ,
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    и
    car_parking_space_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, car_parking_space_record=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 car_parking_space_record is None:
            self.car_parking_space_record = []
        else:
            self.car_parking_space_record = car_parking_space_record
        self.car_parking_space_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsCarParkingSpaceObject)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsCarParkingSpaceObject.subclass:
            return ParamsCarParkingSpaceObject.subclass(*args_, **kwargs_)
        else:
            return ParamsCarParkingSpaceObject(*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_car_parking_space_record(self):
        return self.car_parking_space_record
    def set_car_parking_space_record(self, car_parking_space_record):
        self.car_parking_space_record = car_parking_space_record
    def add_car_parking_space_record(self, value):
        self.car_parking_space_record.append(value)
    def insert_car_parking_space_record_at(self, index, value):
        self.car_parking_space_record.insert(index, value)
    def replace_car_parking_space_record_at(self, index, value):
        self.car_parking_space_record[index] = value
    def has__content(self):
        if (
            self.car_parking_space_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsCarParkingSpaceObject', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsCarParkingSpaceObject')
        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_ == 'ParamsCarParkingSpaceObject':
            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_='ParamsCarParkingSpaceObject')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsCarParkingSpaceObject', 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_='ParamsCarParkingSpaceObject'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsCarParkingSpaceObject', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for car_parking_space_record_ in self.car_parking_space_record:
            namespaceprefix_ = self.car_parking_space_record_nsprefix_ + ':' if (UseCapturedNS_ and self.car_parking_space_record_nsprefix_) else ''
            car_parking_space_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='car_parking_space_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'car_parking_space_record':
            obj_ = car_parking_space_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.car_parking_space_record.append(obj_)
            obj_.original_tagname_ = 'car_parking_space_record'
# end class ParamsCarParkingSpaceObject


class ConstructionRecord(GeneratedsSuper):
    """ConstructionRecord -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    е
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    restrict_records -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, address_location=None, right_record=None, restrict_records=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
        self.right_record = right_record
        self.right_record_nsprefix_ = None
        self.restrict_records = restrict_records
        self.restrict_records_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ConstructionRecord)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ConstructionRecord.subclass:
            return ConstructionRecord.subclass(*args_, **kwargs_)
        else:
            return ConstructionRecord(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def get_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def get_restrict_records(self):
        return self.restrict_records
    def set_restrict_records(self, restrict_records):
        self.restrict_records = restrict_records
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.address_location is not None or
            self.right_record is not None or
            self.restrict_records is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ConstructionRecord', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ConstructionRecord')
        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_ == 'ConstructionRecord':
            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_='ConstructionRecord')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ConstructionRecord', 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_='ConstructionRecord'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ConstructionRecord', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', pretty_print=pretty_print)
        if self.right_record is not None:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            self.right_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', pretty_print=pretty_print)
        if self.restrict_records is not None:
            namespaceprefix_ = self.restrict_records_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_records_nsprefix_) else ''
            self.restrict_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_records', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = ParamsConstructionPurposeUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationConstruction.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
        elif nodeName_ == 'right_record':
            obj_ = RightRecordIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record = obj_
            obj_.original_tagname_ = 'right_record'
        elif nodeName_ == 'restrict_records':
            obj_ = RestrictRecordsIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_records = obj_
            obj_.original_tagname_ = 'restrict_records'
# end class ConstructionRecord


class DataObjectConstruction(GeneratedsSuper):
    """DataObjectConstruction -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    -
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    и
    ,
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    ,
    е
    д
    и
    н
    о
    м
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    м
    к
    о
    м
    п
    л
    е
    к
    с
    е
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    а
    д
    р
    е
    с
    п
    о
    л
    н
    ы
    й
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, address_location=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.object = object
        self.object_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DataObjectConstruction)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DataObjectConstruction.subclass:
            return DataObjectConstruction.subclass(*args_, **kwargs_)
        else:
            return DataObjectConstruction(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def has__content(self):
        if (
            self.object is not None or
            self.address_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectConstruction', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DataObjectConstruction')
        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_ == 'DataObjectConstruction':
            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_='DataObjectConstruction')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DataObjectConstruction', 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_='DataObjectConstruction'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectConstruction', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationConstruction.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
# end class DataObjectConstruction


class ParamsConstructionAll(GeneratedsSuper):
    """ParamsConstructionAll -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    base_parameters -- О
    с
    н
    о
    в
    н
    ы
    е
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    floors -- К
    о
    л
    и
    ч
    е
    с
    т
    в
    о
    э
    т
    а
    ж
    е
    й
    (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    п
    о
    д
    з
    е
    м
    н
    ы
    х
    )
    underground_floors -- К
    о
    л
    и
    ч
    е
    с
    т
    в
    о
    п
    о
    д
    з
    е
    м
    н
    ы
    х
    э
    т
    а
    ж
    е
    й
    purpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    year_commisioning -- Г
    о
    д
    в
    в
    о
    д
    а
    в
    э
    к
    с
    п
    л
    у
    а
    т
    а
    ц
    и
    ю
    п
    о
    з
    а
    в
    е
    р
    ш
    е
    н
    и
    и
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    year_built -- Г
    о
    д
    з
    а
    в
    е
    р
    ш
    е
    н
    и
    я
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    permitted_uses -- В
    и
    д
    (
    ы
    )
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, base_parameters=None, floors=None, underground_floors=None, purpose=None, name=None, year_commisioning=None, year_built=None, permitted_uses=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.base_parameters = base_parameters
        self.base_parameters_nsprefix_ = None
        self.floors = floors
        self.floors_nsprefix_ = None
        self.underground_floors = underground_floors
        self.underground_floors_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
        self.name = name
        self.validate_MultiLiner(self.name)
        self.name_nsprefix_ = None
        self.year_commisioning = year_commisioning
        self.year_commisioning_nsprefix_ = None
        self.year_built = year_built
        self.year_built_nsprefix_ = None
        self.permitted_uses = permitted_uses
        self.permitted_uses_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsConstructionAll)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsConstructionAll.subclass:
            return ParamsConstructionAll.subclass(*args_, **kwargs_)
        else:
            return ParamsConstructionAll(*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_base_parameters(self):
        return self.base_parameters
    def set_base_parameters(self, base_parameters):
        self.base_parameters = base_parameters
    def get_floors(self):
        return self.floors
    def set_floors(self, floors):
        self.floors = floors
    def get_underground_floors(self):
        return self.underground_floors
    def set_underground_floors(self, underground_floors):
        self.underground_floors = underground_floors
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_year_commisioning(self):
        return self.year_commisioning
    def set_year_commisioning(self, year_commisioning):
        self.year_commisioning = year_commisioning
    def get_year_built(self):
        return self.year_built
    def set_year_built(self, year_built):
        self.year_built = year_built
    def get_permitted_uses(self):
        return self.permitted_uses
    def set_permitted_uses(self, permitted_uses):
        self.permitted_uses = permitted_uses
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.base_parameters is not None or
            self.floors is not None or
            self.underground_floors is not None or
            self.purpose is not None or
            self.name is not None or
            self.year_commisioning is not None or
            self.year_built is not None or
            self.permitted_uses is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsConstructionAll', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsConstructionAll')
        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_ == 'ParamsConstructionAll':
            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_='ParamsConstructionAll')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsConstructionAll', 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_='ParamsConstructionAll'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsConstructionAll', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.base_parameters is not None:
            namespaceprefix_ = self.base_parameters_nsprefix_ + ':' if (UseCapturedNS_ and self.base_parameters_nsprefix_) else ''
            self.base_parameters.export(outfile, level, namespaceprefix_, namespacedef_='', name_='base_parameters', pretty_print=pretty_print)
        if self.floors is not None:
            namespaceprefix_ = self.floors_nsprefix_ + ':' if (UseCapturedNS_ and self.floors_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfloors>%s</%sfloors>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.floors), input_name='floors')), namespaceprefix_ , eol_))
        if self.underground_floors is not None:
            namespaceprefix_ = self.underground_floors_nsprefix_ + ':' if (UseCapturedNS_ and self.underground_floors_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sunderground_floors>%s</%sunderground_floors>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.underground_floors), input_name='underground_floors')), namespaceprefix_ , eol_))
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spurpose>%s</%spurpose>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.purpose), input_name='purpose')), 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.year_commisioning is not None:
            namespaceprefix_ = self.year_commisioning_nsprefix_ + ':' if (UseCapturedNS_ and self.year_commisioning_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%syear_commisioning>%s</%syear_commisioning>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.year_commisioning), input_name='year_commisioning')), namespaceprefix_ , eol_))
        if self.year_built is not None:
            namespaceprefix_ = self.year_built_nsprefix_ + ':' if (UseCapturedNS_ and self.year_built_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%syear_built>%s</%syear_built>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.year_built), input_name='year_built')), namespaceprefix_ , eol_))
        if self.permitted_uses is not None:
            namespaceprefix_ = self.permitted_uses_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_uses_nsprefix_) else ''
            self.permitted_uses.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_uses', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'base_parameters':
            obj_ = BaseParameters.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.base_parameters = obj_
            obj_.original_tagname_ = 'base_parameters'
        elif nodeName_ == 'floors':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'floors')
            value_ = self.gds_validate_string(value_, node, 'floors')
            self.floors = value_
            self.floors_nsprefix_ = child_.prefix
        elif nodeName_ == 'underground_floors':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'underground_floors')
            value_ = self.gds_validate_string(value_, node, 'underground_floors')
            self.underground_floors = value_
            self.underground_floors_nsprefix_ = child_.prefix
        elif nodeName_ == 'purpose':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'purpose')
            value_ = self.gds_validate_string(value_, node, 'purpose')
            self.purpose = value_
            self.purpose_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
            # validate type MultiLiner
            self.validate_MultiLiner(self.name)
        elif nodeName_ == 'year_commisioning':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'year_commisioning')
            value_ = self.gds_validate_string(value_, node, 'year_commisioning')
            self.year_commisioning = value_
            self.year_commisioning_nsprefix_ = child_.prefix
        elif nodeName_ == 'year_built':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'year_built')
            value_ = self.gds_validate_string(value_, node, 'year_built')
            self.year_built = value_
            self.year_built_nsprefix_ = child_.prefix
        elif nodeName_ == 'permitted_uses':
            obj_ = PermittedUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_uses = obj_
            obj_.original_tagname_ = 'permitted_uses'
# end class ParamsConstructionAll


class ParamsConstructionPurposeUses(GeneratedsSuper):
    """ParamsConstructionPurposeUses -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    (
    о
    с
    н
    о
    в
    н
    ы
    е
    п
    а
    р
    а
    м
    е
    т
    р
    ы
    ,
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    ,
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    )
    base_parameters -- О
    с
    н
    о
    в
    н
    ы
    е
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    purpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    permitted_uses -- В
    и
    д
    (
    ы
    )
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, base_parameters=None, purpose=None, permitted_uses=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.base_parameters = base_parameters
        self.base_parameters_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
        self.permitted_uses = permitted_uses
        self.permitted_uses_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsConstructionPurposeUses)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsConstructionPurposeUses.subclass:
            return ParamsConstructionPurposeUses.subclass(*args_, **kwargs_)
        else:
            return ParamsConstructionPurposeUses(*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_base_parameters(self):
        return self.base_parameters
    def set_base_parameters(self, base_parameters):
        self.base_parameters = base_parameters
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def get_permitted_uses(self):
        return self.permitted_uses
    def set_permitted_uses(self, permitted_uses):
        self.permitted_uses = permitted_uses
    def has__content(self):
        if (
            self.base_parameters is not None or
            self.purpose is not None or
            self.permitted_uses is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsConstructionPurposeUses', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsConstructionPurposeUses')
        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_ == 'ParamsConstructionPurposeUses':
            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_='ParamsConstructionPurposeUses')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsConstructionPurposeUses', 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_='ParamsConstructionPurposeUses'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsConstructionPurposeUses', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.base_parameters is not None:
            namespaceprefix_ = self.base_parameters_nsprefix_ + ':' if (UseCapturedNS_ and self.base_parameters_nsprefix_) else ''
            self.base_parameters.export(outfile, level, namespaceprefix_, namespacedef_='', name_='base_parameters', pretty_print=pretty_print)
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spurpose>%s</%spurpose>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.purpose), input_name='purpose')), namespaceprefix_ , eol_))
        if self.permitted_uses is not None:
            namespaceprefix_ = self.permitted_uses_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_uses_nsprefix_) else ''
            self.permitted_uses.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_uses', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'base_parameters':
            obj_ = BaseParameters.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.base_parameters = obj_
            obj_.original_tagname_ = 'base_parameters'
        elif nodeName_ == 'purpose':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'purpose')
            value_ = self.gds_validate_string(value_, node, 'purpose')
            self.purpose = value_
            self.purpose_nsprefix_ = child_.prefix
        elif nodeName_ == 'permitted_uses':
            obj_ = PermittedUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_uses = obj_
            obj_.original_tagname_ = 'permitted_uses'
# end class ParamsConstructionPurposeUses


class ParamsConstructionPurpose(GeneratedsSuper):
    """ParamsConstructionPurpose -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    о
    с
    н
    о
    в
    н
    ы
    е
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    ,
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    )
    base_parameters -- О
    с
    н
    о
    в
    н
    ы
    е
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    purpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, base_parameters=None, purpose=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.base_parameters = base_parameters
        self.base_parameters_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsConstructionPurpose)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsConstructionPurpose.subclass:
            return ParamsConstructionPurpose.subclass(*args_, **kwargs_)
        else:
            return ParamsConstructionPurpose(*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_base_parameters(self):
        return self.base_parameters
    def set_base_parameters(self, base_parameters):
        self.base_parameters = base_parameters
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def has__content(self):
        if (
            self.base_parameters is not None or
            self.purpose is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsConstructionPurpose', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsConstructionPurpose')
        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_ == 'ParamsConstructionPurpose':
            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_='ParamsConstructionPurpose')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsConstructionPurpose', 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_='ParamsConstructionPurpose'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsConstructionPurpose', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.base_parameters is not None:
            namespaceprefix_ = self.base_parameters_nsprefix_ + ':' if (UseCapturedNS_ and self.base_parameters_nsprefix_) else ''
            self.base_parameters.export(outfile, level, namespaceprefix_, namespacedef_='', name_='base_parameters', pretty_print=pretty_print)
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spurpose>%s</%spurpose>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.purpose), input_name='purpose')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'base_parameters':
            obj_ = BaseParameters.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.base_parameters = obj_
            obj_.original_tagname_ = 'base_parameters'
        elif nodeName_ == 'purpose':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'purpose')
            value_ = self.gds_validate_string(value_, node, 'purpose')
            self.purpose = value_
            self.purpose_nsprefix_ = child_.prefix
# end class ParamsConstructionPurpose


class ObjectUnderConstructionRecord(GeneratedsSuper):
    """ObjectUnderConstructionRecord -- О
    б
    ъ
    е
    к
    т
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    (
    п
    р
    о
    е
    к
    т
    и
    р
    у
    е
    м
    ы
    е
    з
    н
    а
    ч
    е
    н
    и
    я
    о
    с
    н
    о
    в
    н
    ы
    х
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    ,
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    я
    )
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    restrict_records -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, address_location=None, right_record=None, restrict_records=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
        self.right_record = right_record
        self.right_record_nsprefix_ = None
        self.restrict_records = restrict_records
        self.restrict_records_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectUnderConstructionRecord)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectUnderConstructionRecord.subclass:
            return ObjectUnderConstructionRecord.subclass(*args_, **kwargs_)
        else:
            return ObjectUnderConstructionRecord(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def get_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def get_restrict_records(self):
        return self.restrict_records
    def set_restrict_records(self, restrict_records):
        self.restrict_records = restrict_records
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.address_location is not None or
            self.right_record is not None or
            self.restrict_records is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectUnderConstructionRecord', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectUnderConstructionRecord')
        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_ == 'ObjectUnderConstructionRecord':
            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_='ObjectUnderConstructionRecord')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectUnderConstructionRecord', 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_='ObjectUnderConstructionRecord'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectUnderConstructionRecord', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', pretty_print=pretty_print)
        if self.right_record is not None:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            self.right_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', pretty_print=pretty_print)
        if self.restrict_records is not None:
            namespaceprefix_ = self.restrict_records_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_records_nsprefix_) else ''
            self.restrict_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_records', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = ParamsConstructionPurpose.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationConstruction.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
        elif nodeName_ == 'right_record':
            obj_ = RightRecordIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record = obj_
            obj_.original_tagname_ = 'right_record'
        elif nodeName_ == 'restrict_records':
            obj_ = RestrictRecordsIndividNoPart.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_records = obj_
            obj_.original_tagname_ = 'restrict_records'
# end class ObjectUnderConstructionRecord


class ParamsUnderConstructionDegree(GeneratedsSuper):
    """ParamsUnderConstructionDegree -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    (
    о
    с
    н
    о
    в
    н
    ы
    е
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    ,
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    ,
    с
    т
    е
    п
    е
    н
    ь
    г
    о
    т
    о
    в
    н
    о
    с
    т
    и
    )
    base_parameters -- О
    с
    н
    о
    в
    н
    ы
    е
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    и
    и
    х
    п
    р
    о
    е
    к
    т
    и
    р
    у
    е
    м
    ы
    е
    з
    н
    а
    ч
    е
    н
    и
    я
    degree_readiness -- С
    т
    е
    п
    е
    н
    ь
    г
    о
    т
    о
    в
    н
    о
    с
    т
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    в
    п
    р
    о
    ц
    е
    н
    т
    а
    х
    purpose -- П
    р
    о
    е
    к
    т
    и
    р
    у
    е
    м
    о
    е
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, base_parameters=None, degree_readiness=None, purpose=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.base_parameters = base_parameters
        self.base_parameters_nsprefix_ = None
        self.degree_readiness = degree_readiness
        self.degree_readiness_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsUnderConstructionDegree)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsUnderConstructionDegree.subclass:
            return ParamsUnderConstructionDegree.subclass(*args_, **kwargs_)
        else:
            return ParamsUnderConstructionDegree(*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_base_parameters(self):
        return self.base_parameters
    def set_base_parameters(self, base_parameters):
        self.base_parameters = base_parameters
    def get_degree_readiness(self):
        return self.degree_readiness
    def set_degree_readiness(self, degree_readiness):
        self.degree_readiness = degree_readiness
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def has__content(self):
        if (
            self.base_parameters is not None or
            self.degree_readiness is not None or
            self.purpose is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsUnderConstructionDegree', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsUnderConstructionDegree')
        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_ == 'ParamsUnderConstructionDegree':
            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_='ParamsUnderConstructionDegree')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsUnderConstructionDegree', 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_='ParamsUnderConstructionDegree'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsUnderConstructionDegree', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.base_parameters is not None:
            namespaceprefix_ = self.base_parameters_nsprefix_ + ':' if (UseCapturedNS_ and self.base_parameters_nsprefix_) else ''
            self.base_parameters.export(outfile, level, namespaceprefix_, namespacedef_='', name_='base_parameters', pretty_print=pretty_print)
        if self.degree_readiness is not None:
            namespaceprefix_ = self.degree_readiness_nsprefix_ + ':' if (UseCapturedNS_ and self.degree_readiness_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdegree_readiness>%s</%sdegree_readiness>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.degree_readiness), input_name='degree_readiness')), namespaceprefix_ , eol_))
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spurpose>%s</%spurpose>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.purpose), input_name='purpose')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'base_parameters':
            obj_ = BaseParameters.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.base_parameters = obj_
            obj_.original_tagname_ = 'base_parameters'
        elif nodeName_ == 'degree_readiness':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'degree_readiness')
            value_ = self.gds_validate_string(value_, node, 'degree_readiness')
            self.degree_readiness = value_
            self.degree_readiness_nsprefix_ = child_.prefix
        elif nodeName_ == 'purpose':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'purpose')
            value_ = self.gds_validate_string(value_, node, 'purpose')
            self.purpose = value_
            self.purpose_nsprefix_ = child_.prefix
# end class ParamsUnderConstructionDegree


class PropertyComplexRecord(GeneratedsSuper):
    """PropertyComplexRecord -- П
    р
    е
    д
    п
    р
    и
    я
    т
    и
    е
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    ы
    й
    к
    о
    м
    п
    л
    е
    к
    с
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    )
    address -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    ,
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    (
    а
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    н
    а
    х
    о
    ж
    е
    н
    и
    е
    )
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    )
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    restrict_records -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, address=None, right_record=None, restrict_records=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address = address
        self.address_nsprefix_ = None
        self.right_record = right_record
        self.right_record_nsprefix_ = None
        self.restrict_records = restrict_records
        self.restrict_records_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PropertyComplexRecord)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PropertyComplexRecord.subclass:
            return PropertyComplexRecord.subclass(*args_, **kwargs_)
        else:
            return PropertyComplexRecord(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def get_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def get_restrict_records(self):
        return self.restrict_records
    def set_restrict_records(self, restrict_records):
        self.restrict_records = restrict_records
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.address is not None or
            self.right_record is not None or
            self.restrict_records is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PropertyComplexRecord', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PropertyComplexRecord')
        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_ == 'PropertyComplexRecord':
            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_='PropertyComplexRecord')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PropertyComplexRecord', 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_='PropertyComplexRecord'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PropertyComplexRecord', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', pretty_print=pretty_print)
        if self.right_record is not None:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            self.right_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', pretty_print=pretty_print)
        if self.restrict_records is not None:
            namespaceprefix_ = self.restrict_records_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_records_nsprefix_) else ''
            self.restrict_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_records', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = ParamsPurpose.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address':
            obj_ = AddressLocationPropertyComplex.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
        elif nodeName_ == 'right_record':
            obj_ = RightRecordIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record = obj_
            obj_.original_tagname_ = 'right_record'
        elif nodeName_ == 'restrict_records':
            obj_ = RestrictRecordsIndividNoPart.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_records = obj_
            obj_.original_tagname_ = 'restrict_records'
# end class PropertyComplexRecord


class DataObjectPropertyComplex(GeneratedsSuper):
    """DataObjectPropertyComplex -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    -
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    и
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    м
    к
    о
    м
    п
    л
    е
    к
    с
    е
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    а
    д
    р
    е
    с
    п
    о
    л
    н
    ы
    й
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    address -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    ,
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    (
    а
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    н
    а
    х
    о
    ж
    е
    н
    и
    е
    )
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, address=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.object = object
        self.object_nsprefix_ = None
        self.address = address
        self.address_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DataObjectPropertyComplex)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DataObjectPropertyComplex.subclass:
            return DataObjectPropertyComplex.subclass(*args_, **kwargs_)
        else:
            return DataObjectPropertyComplex(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def has__content(self):
        if (
            self.object is not None or
            self.address is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectPropertyComplex', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DataObjectPropertyComplex')
        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_ == 'DataObjectPropertyComplex':
            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_='DataObjectPropertyComplex')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DataObjectPropertyComplex', 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_='DataObjectPropertyComplex'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObjectPropertyComplex', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'address':
            obj_ = AddressLocationPropertyComplex.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
# end class DataObjectPropertyComplex


class PropertyComplexRecordParams(GeneratedsSuper):
    """PropertyComplexRecordParams -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    -
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    и
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    м
    к
    о
    м
    п
    л
    е
    к
    с
    е
    record_info -- Д
    а
    т
    ы
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    cad_links -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    address -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    cost_info -- С
    в
    е
    д
    е
    н
    и
    я
    о
    с
    т
    о
    и
    м
    о
    с
    т
    и
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    special_notes -- О
    с
    о
    б
    ы
    е
    о
    т
    м
    е
    т
    к
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, object=None, cad_links=None, params=None, address=None, cost_info=None, special_notes=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.object = object
        self.object_nsprefix_ = None
        self.cad_links = cad_links
        self.cad_links_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address = address
        self.address_nsprefix_ = None
        self.cost_info = cost_info
        self.cost_info_nsprefix_ = None
        self.special_notes = special_notes
        self.special_notes_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PropertyComplexRecordParams)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PropertyComplexRecordParams.subclass:
            return PropertyComplexRecordParams.subclass(*args_, **kwargs_)
        else:
            return PropertyComplexRecordParams(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_cad_links(self):
        return self.cad_links
    def set_cad_links(self, cad_links):
        self.cad_links = cad_links
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def get_cost_info(self):
        return self.cost_info
    def set_cost_info(self, cost_info):
        self.cost_info = cost_info
    def get_special_notes(self):
        return self.special_notes
    def set_special_notes(self, special_notes):
        self.special_notes = special_notes
    def has__content(self):
        if (
            self.record_info is not None or
            self.object is not None or
            self.cad_links is not None or
            self.params is not None or
            self.address is not None or
            self.cost_info is not None or
            self.special_notes is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PropertyComplexRecordParams', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PropertyComplexRecordParams')
        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_ == 'PropertyComplexRecordParams':
            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_='PropertyComplexRecordParams')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PropertyComplexRecordParams', 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_='PropertyComplexRecordParams'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PropertyComplexRecordParams', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.cad_links is not None:
            namespaceprefix_ = self.cad_links_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_links_nsprefix_) else ''
            self.cad_links.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cad_links', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', pretty_print=pretty_print)
        if self.cost_info is not None:
            namespaceprefix_ = self.cost_info_nsprefix_ + ':' if (UseCapturedNS_ and self.cost_info_nsprefix_) else ''
            self.cost_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cost_info', pretty_print=pretty_print)
        if self.special_notes is not None:
            namespaceprefix_ = self.special_notes_nsprefix_ + ':' if (UseCapturedNS_ and self.special_notes_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sspecial_notes>%s</%sspecial_notes>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.special_notes), input_name='special_notes')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RecordInfo.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'object':
            obj_ = ObjectCommonData.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'cad_links':
            obj_ = CadLinksComplex.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cad_links = obj_
            obj_.original_tagname_ = 'cad_links'
        elif nodeName_ == 'params':
            obj_ = ParamsComplex.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address':
            obj_ = AddressLocationPropertyComplex.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
        elif nodeName_ == 'cost_info':
            obj_ = CostInfo.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cost_info = obj_
            obj_.original_tagname_ = 'cost_info'
        elif nodeName_ == 'special_notes':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'special_notes')
            value_ = self.gds_validate_string(value_, node, 'special_notes')
            self.special_notes = value_
            self.special_notes_nsprefix_ = child_.prefix
# end class PropertyComplexRecordParams


class UnifiedRealEstateComplexRecord(GeneratedsSuper):
    """UnifiedRealEstateComplexRecord -- Е
    д
    и
    н
    ы
    й
    н
    е
    д
    в
    и
    ж
    и
    м
    ы
    й
    к
    о
    м
    п
    л
    е
    к
    с
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    )
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    restrict_records -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, address_location=None, right_record=None, restrict_records=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
        self.right_record = right_record
        self.right_record_nsprefix_ = None
        self.restrict_records = restrict_records
        self.restrict_records_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, UnifiedRealEstateComplexRecord)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if UnifiedRealEstateComplexRecord.subclass:
            return UnifiedRealEstateComplexRecord.subclass(*args_, **kwargs_)
        else:
            return UnifiedRealEstateComplexRecord(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def get_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def get_restrict_records(self):
        return self.restrict_records
    def set_restrict_records(self, restrict_records):
        self.restrict_records = restrict_records
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.address_location is not None or
            self.right_record is not None or
            self.restrict_records is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnifiedRealEstateComplexRecord', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnifiedRealEstateComplexRecord')
        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_ == 'UnifiedRealEstateComplexRecord':
            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_='UnifiedRealEstateComplexRecord')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnifiedRealEstateComplexRecord', 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_='UnifiedRealEstateComplexRecord'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnifiedRealEstateComplexRecord', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', pretty_print=pretty_print)
        if self.right_record is not None:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            self.right_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', pretty_print=pretty_print)
        if self.restrict_records is not None:
            namespaceprefix_ = self.restrict_records_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_records_nsprefix_) else ''
            self.restrict_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_records', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = ParamsPurpose.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationConstruction.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
        elif nodeName_ == 'right_record':
            obj_ = RightRecordIndivid.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record = obj_
            obj_.original_tagname_ = 'right_record'
        elif nodeName_ == 'restrict_records':
            obj_ = RestrictRecordsIndividNoPart.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_records = obj_
            obj_.original_tagname_ = 'restrict_records'
# end class UnifiedRealEstateComplexRecord


class ParamsComplex(GeneratedsSuper):
    """ParamsComplex -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    к
    о
    м
    п
    л
    е
    к
    с
    а
    purpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, purpose=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.purpose = purpose
        self.purpose_nsprefix_ = None
        self.name = name
        self.validate_MultiLiner(self.name)
        self.name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsComplex)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsComplex.subclass:
            return ParamsComplex.subclass(*args_, **kwargs_)
        else:
            return ParamsComplex(*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_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.purpose is not None or
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsComplex', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsComplex')
        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_ == 'ParamsComplex':
            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_='ParamsComplex')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsComplex', 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_='ParamsComplex'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsComplex', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spurpose>%s</%spurpose>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.purpose), input_name='purpose')), 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_))
    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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'purpose':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'purpose')
            value_ = self.gds_validate_string(value_, node, 'purpose')
            self.purpose = value_
            self.purpose_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
            # validate type MultiLiner
            self.validate_MultiLiner(self.name)
# end class ParamsComplex


class ParamsPurpose(GeneratedsSuper):
    """ParamsPurpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    purpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, purpose=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.purpose = purpose
        self.purpose_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ParamsPurpose)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ParamsPurpose.subclass:
            return ParamsPurpose.subclass(*args_, **kwargs_)
        else:
            return ParamsPurpose(*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_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def has__content(self):
        if (
            self.purpose is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsPurpose', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ParamsPurpose')
        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_ == 'ParamsPurpose':
            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_='ParamsPurpose')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ParamsPurpose', 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_='ParamsPurpose'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ParamsPurpose', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spurpose>%s</%spurpose>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.purpose), input_name='purpose')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'purpose':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'purpose')
            value_ = self.gds_validate_string(value_, node, 'purpose')
            self.purpose = value_
            self.purpose_nsprefix_ = child_.prefix
# end class ParamsPurpose


class BaseDataRightRestrictIndivid(GeneratedsSuper):
    """BaseDataRightRestrictIndivid -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    (
    о
    б
    ъ
    е
    к
    т
    а
    х
    )
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    п
    р
    а
    в
    а
    х
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    ,
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    land_records -- З
    е
    м
    е
    л
    ь
    н
    ы
    е
    у
    ч
    а
    с
    т
    к
    и
    room_records -- П
    о
    м
    е
    щ
    е
    н
    и
    я
    car_parking_space_records -- М
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    property_complex_records -- П
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    ы
    е
    к
    о
    м
    п
    л
    е
    к
    с
    ы
    unified_real_estate_complex_records -- Е
    д
    и
    н
    ы
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    ы
    е
    к
    о
    м
    п
    л
    е
    к
    с
    ы
    object_under_construction_records -- О
    б
    ъ
    е
    к
    т
    ы
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    build_records -- З
    д
    а
    н
    и
    я
    construction_records -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_records=None, room_records=None, car_parking_space_records=None, property_complex_records=None, unified_real_estate_complex_records=None, object_under_construction_records=None, build_records=None, construction_records=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.land_records = land_records
        self.land_records_nsprefix_ = None
        self.room_records = room_records
        self.room_records_nsprefix_ = None
        self.car_parking_space_records = car_parking_space_records
        self.car_parking_space_records_nsprefix_ = None
        self.property_complex_records = property_complex_records
        self.property_complex_records_nsprefix_ = None
        self.unified_real_estate_complex_records = unified_real_estate_complex_records
        self.unified_real_estate_complex_records_nsprefix_ = None
        self.object_under_construction_records = object_under_construction_records
        self.object_under_construction_records_nsprefix_ = None
        self.build_records = build_records
        self.build_records_nsprefix_ = None
        self.construction_records = construction_records
        self.construction_records_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BaseDataRightRestrictIndivid)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BaseDataRightRestrictIndivid.subclass:
            return BaseDataRightRestrictIndivid.subclass(*args_, **kwargs_)
        else:
            return BaseDataRightRestrictIndivid(*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_land_records(self):
        return self.land_records
    def set_land_records(self, land_records):
        self.land_records = land_records
    def get_room_records(self):
        return self.room_records
    def set_room_records(self, room_records):
        self.room_records = room_records
    def get_car_parking_space_records(self):
        return self.car_parking_space_records
    def set_car_parking_space_records(self, car_parking_space_records):
        self.car_parking_space_records = car_parking_space_records
    def get_property_complex_records(self):
        return self.property_complex_records
    def set_property_complex_records(self, property_complex_records):
        self.property_complex_records = property_complex_records
    def get_unified_real_estate_complex_records(self):
        return self.unified_real_estate_complex_records
    def set_unified_real_estate_complex_records(self, unified_real_estate_complex_records):
        self.unified_real_estate_complex_records = unified_real_estate_complex_records
    def get_object_under_construction_records(self):
        return self.object_under_construction_records
    def set_object_under_construction_records(self, object_under_construction_records):
        self.object_under_construction_records = object_under_construction_records
    def get_build_records(self):
        return self.build_records
    def set_build_records(self, build_records):
        self.build_records = build_records
    def get_construction_records(self):
        return self.construction_records
    def set_construction_records(self, construction_records):
        self.construction_records = construction_records
    def has__content(self):
        if (
            self.land_records is not None or
            self.room_records is not None or
            self.car_parking_space_records is not None or
            self.property_complex_records is not None or
            self.unified_real_estate_complex_records is not None or
            self.object_under_construction_records is not None or
            self.build_records is not None or
            self.construction_records is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BaseDataRightRestrictIndivid', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BaseDataRightRestrictIndivid')
        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_ == 'BaseDataRightRestrictIndivid':
            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_='BaseDataRightRestrictIndivid')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BaseDataRightRestrictIndivid', 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_='BaseDataRightRestrictIndivid'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BaseDataRightRestrictIndivid', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.land_records is not None:
            namespaceprefix_ = self.land_records_nsprefix_ + ':' if (UseCapturedNS_ and self.land_records_nsprefix_) else ''
            self.land_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_records', pretty_print=pretty_print)
        if self.room_records is not None:
            namespaceprefix_ = self.room_records_nsprefix_ + ':' if (UseCapturedNS_ and self.room_records_nsprefix_) else ''
            self.room_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_records', pretty_print=pretty_print)
        if self.car_parking_space_records is not None:
            namespaceprefix_ = self.car_parking_space_records_nsprefix_ + ':' if (UseCapturedNS_ and self.car_parking_space_records_nsprefix_) else ''
            self.car_parking_space_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='car_parking_space_records', pretty_print=pretty_print)
        if self.property_complex_records is not None:
            namespaceprefix_ = self.property_complex_records_nsprefix_ + ':' if (UseCapturedNS_ and self.property_complex_records_nsprefix_) else ''
            self.property_complex_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='property_complex_records', pretty_print=pretty_print)
        if self.unified_real_estate_complex_records is not None:
            namespaceprefix_ = self.unified_real_estate_complex_records_nsprefix_ + ':' if (UseCapturedNS_ and self.unified_real_estate_complex_records_nsprefix_) else ''
            self.unified_real_estate_complex_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='unified_real_estate_complex_records', pretty_print=pretty_print)
        if self.object_under_construction_records is not None:
            namespaceprefix_ = self.object_under_construction_records_nsprefix_ + ':' if (UseCapturedNS_ and self.object_under_construction_records_nsprefix_) else ''
            self.object_under_construction_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_under_construction_records', pretty_print=pretty_print)
        if self.build_records is not None:
            namespaceprefix_ = self.build_records_nsprefix_ + ':' if (UseCapturedNS_ and self.build_records_nsprefix_) else ''
            self.build_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='build_records', pretty_print=pretty_print)
        if self.construction_records is not None:
            namespaceprefix_ = self.construction_records_nsprefix_ + ':' if (UseCapturedNS_ and self.construction_records_nsprefix_) else ''
            self.construction_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='construction_records', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_records':
            obj_ = land_recordsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_records = obj_
            obj_.original_tagname_ = 'land_records'
        elif nodeName_ == 'room_records':
            obj_ = room_recordsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_records = obj_
            obj_.original_tagname_ = 'room_records'
        elif nodeName_ == 'car_parking_space_records':
            obj_ = car_parking_space_recordsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.car_parking_space_records = obj_
            obj_.original_tagname_ = 'car_parking_space_records'
        elif nodeName_ == 'property_complex_records':
            obj_ = property_complex_recordsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.property_complex_records = obj_
            obj_.original_tagname_ = 'property_complex_records'
        elif nodeName_ == 'unified_real_estate_complex_records':
            obj_ = unified_real_estate_complex_recordsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.unified_real_estate_complex_records = obj_
            obj_.original_tagname_ = 'unified_real_estate_complex_records'
        elif nodeName_ == 'object_under_construction_records':
            obj_ = object_under_construction_recordsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_under_construction_records = obj_
            obj_.original_tagname_ = 'object_under_construction_records'
        elif nodeName_ == 'build_records':
            obj_ = build_recordsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.build_records = obj_
            obj_.original_tagname_ = 'build_records'
        elif nodeName_ == 'construction_records':
            obj_ = construction_recordsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.construction_records = obj_
            obj_.original_tagname_ = 'construction_records'
# end class BaseDataRightRestrictIndivid


class DataObject(GeneratedsSuper):
    """DataObject -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    а
    д
    р
    е
    с
    т
    е
    к
    с
    т
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, address_location=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.object = object
        self.object_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DataObject)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DataObject.subclass:
            return DataObject.subclass(*args_, **kwargs_)
        else:
            return DataObject(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def has__content(self):
        if (
            self.object is not None or
            self.address_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObject', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DataObject')
        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_ == 'DataObject':
            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_='DataObject')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DataObject', 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_='DataObject'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DataObject', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationText.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
# end class DataObject


class BaseData(GeneratedsSuper):
    """BaseData -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    а
    д
    р
    е
    с
    п
    о
    л
    н
    ы
    й
    )
    land_record -- З
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    room_record -- П
    о
    м
    е
    щ
    е
    н
    и
    е
    car_parking_space_record -- М
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    property_complex_record -- П
    р
    е
    д
    п
    р
    и
    я
    т
    и
    е
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    ы
    й
    к
    о
    м
    п
    л
    е
    к
    с
    unified_real_estate_complex_record -- Е
    д
    и
    н
    ы
    й
    н
    е
    д
    в
    и
    ж
    и
    м
    ы
    й
    к
    о
    м
    п
    л
    е
    к
    с
    object_under_construction_record -- О
    б
    ъ
    е
    к
    т
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    build_record -- З
    д
    а
    н
    и
    е
    construction_record -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_record=None, room_record=None, car_parking_space_record=None, property_complex_record=None, unified_real_estate_complex_record=None, object_under_construction_record=None, build_record=None, construction_record=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.land_record = land_record
        self.land_record_nsprefix_ = None
        self.room_record = room_record
        self.room_record_nsprefix_ = None
        self.car_parking_space_record = car_parking_space_record
        self.car_parking_space_record_nsprefix_ = None
        self.property_complex_record = property_complex_record
        self.property_complex_record_nsprefix_ = None
        self.unified_real_estate_complex_record = unified_real_estate_complex_record
        self.unified_real_estate_complex_record_nsprefix_ = None
        self.object_under_construction_record = object_under_construction_record
        self.object_under_construction_record_nsprefix_ = None
        self.build_record = build_record
        self.build_record_nsprefix_ = None
        self.construction_record = construction_record
        self.construction_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BaseData)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BaseData.subclass:
            return BaseData.subclass(*args_, **kwargs_)
        else:
            return BaseData(*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_land_record(self):
        return self.land_record
    def set_land_record(self, land_record):
        self.land_record = land_record
    def get_room_record(self):
        return self.room_record
    def set_room_record(self, room_record):
        self.room_record = room_record
    def get_car_parking_space_record(self):
        return self.car_parking_space_record
    def set_car_parking_space_record(self, car_parking_space_record):
        self.car_parking_space_record = car_parking_space_record
    def get_property_complex_record(self):
        return self.property_complex_record
    def set_property_complex_record(self, property_complex_record):
        self.property_complex_record = property_complex_record
    def get_unified_real_estate_complex_record(self):
        return self.unified_real_estate_complex_record
    def set_unified_real_estate_complex_record(self, unified_real_estate_complex_record):
        self.unified_real_estate_complex_record = unified_real_estate_complex_record
    def get_object_under_construction_record(self):
        return self.object_under_construction_record
    def set_object_under_construction_record(self, object_under_construction_record):
        self.object_under_construction_record = object_under_construction_record
    def get_build_record(self):
        return self.build_record
    def set_build_record(self, build_record):
        self.build_record = build_record
    def get_construction_record(self):
        return self.construction_record
    def set_construction_record(self, construction_record):
        self.construction_record = construction_record
    def has__content(self):
        if (
            self.land_record is not None or
            self.room_record is not None or
            self.car_parking_space_record is not None or
            self.property_complex_record is not None or
            self.unified_real_estate_complex_record is not None or
            self.object_under_construction_record is not None or
            self.build_record is not None or
            self.construction_record is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BaseData', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BaseData')
        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_ == 'BaseData':
            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_='BaseData')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BaseData', 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_='BaseData'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BaseData', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.land_record is not None:
            namespaceprefix_ = self.land_record_nsprefix_ + ':' if (UseCapturedNS_ and self.land_record_nsprefix_) else ''
            self.land_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_record', pretty_print=pretty_print)
        if self.room_record is not None:
            namespaceprefix_ = self.room_record_nsprefix_ + ':' if (UseCapturedNS_ and self.room_record_nsprefix_) else ''
            self.room_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_record', pretty_print=pretty_print)
        if self.car_parking_space_record is not None:
            namespaceprefix_ = self.car_parking_space_record_nsprefix_ + ':' if (UseCapturedNS_ and self.car_parking_space_record_nsprefix_) else ''
            self.car_parking_space_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='car_parking_space_record', pretty_print=pretty_print)
        if self.property_complex_record is not None:
            namespaceprefix_ = self.property_complex_record_nsprefix_ + ':' if (UseCapturedNS_ and self.property_complex_record_nsprefix_) else ''
            self.property_complex_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='property_complex_record', pretty_print=pretty_print)
        if self.unified_real_estate_complex_record is not None:
            namespaceprefix_ = self.unified_real_estate_complex_record_nsprefix_ + ':' if (UseCapturedNS_ and self.unified_real_estate_complex_record_nsprefix_) else ''
            self.unified_real_estate_complex_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='unified_real_estate_complex_record', pretty_print=pretty_print)
        if self.object_under_construction_record is not None:
            namespaceprefix_ = self.object_under_construction_record_nsprefix_ + ':' if (UseCapturedNS_ and self.object_under_construction_record_nsprefix_) else ''
            self.object_under_construction_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_under_construction_record', pretty_print=pretty_print)
        if self.build_record is not None:
            namespaceprefix_ = self.build_record_nsprefix_ + ':' if (UseCapturedNS_ and self.build_record_nsprefix_) else ''
            self.build_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='build_record', pretty_print=pretty_print)
        if self.construction_record is not None:
            namespaceprefix_ = self.construction_record_nsprefix_ + ':' if (UseCapturedNS_ and self.construction_record_nsprefix_) else ''
            self.construction_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='construction_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_record':
            obj_ = DataObjectLand.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_record = obj_
            obj_.original_tagname_ = 'land_record'
        elif nodeName_ == 'room_record':
            obj_ = DataObjectRoom.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_record = obj_
            obj_.original_tagname_ = 'room_record'
        elif nodeName_ == 'car_parking_space_record':
            obj_ = DataObjectCarParkingSpace.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.car_parking_space_record = obj_
            obj_.original_tagname_ = 'car_parking_space_record'
        elif nodeName_ == 'property_complex_record':
            obj_ = DataObjectPropertyComplex.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.property_complex_record = obj_
            obj_.original_tagname_ = 'property_complex_record'
        elif nodeName_ == 'unified_real_estate_complex_record':
            obj_ = DataObjectConstruction.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.unified_real_estate_complex_record = obj_
            obj_.original_tagname_ = 'unified_real_estate_complex_record'
        elif nodeName_ == 'object_under_construction_record':
            obj_ = DataObjectConstruction.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_under_construction_record = obj_
            obj_.original_tagname_ = 'object_under_construction_record'
        elif nodeName_ == 'build_record':
            obj_ = DataObjectBuild.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.build_record = obj_
            obj_.original_tagname_ = 'build_record'
        elif nodeName_ == 'construction_record':
            obj_ = DataObjectConstruction.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.construction_record = obj_
            obj_.original_tagname_ = 'construction_record'
# end class BaseData


class BaseDataNotice(GeneratedsSuper):
    """BaseDataNotice -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    land_record -- З
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    room_record -- П
    о
    м
    е
    щ
    е
    н
    и
    е
    car_parking_space_record -- М
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    property_complex_record -- П
    р
    е
    д
    п
    р
    и
    я
    т
    и
    е
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    ы
    й
    к
    о
    м
    п
    л
    е
    к
    с
    unified_real_estate_complex_record -- Е
    д
    и
    н
    ы
    й
    н
    е
    д
    в
    и
    ж
    и
    м
    ы
    й
    к
    о
    м
    п
    л
    е
    к
    с
    object_under_construction_record -- О
    б
    ъ
    е
    к
    т
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    build_record -- З
    д
    а
    н
    и
    е
    construction_record -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_record=None, room_record=None, car_parking_space_record=None, property_complex_record=None, unified_real_estate_complex_record=None, object_under_construction_record=None, build_record=None, construction_record=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.land_record = land_record
        self.land_record_nsprefix_ = None
        self.room_record = room_record
        self.room_record_nsprefix_ = None
        self.car_parking_space_record = car_parking_space_record
        self.car_parking_space_record_nsprefix_ = None
        self.property_complex_record = property_complex_record
        self.property_complex_record_nsprefix_ = None
        self.unified_real_estate_complex_record = unified_real_estate_complex_record
        self.unified_real_estate_complex_record_nsprefix_ = None
        self.object_under_construction_record = object_under_construction_record
        self.object_under_construction_record_nsprefix_ = None
        self.build_record = build_record
        self.build_record_nsprefix_ = None
        self.construction_record = construction_record
        self.construction_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BaseDataNotice)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BaseDataNotice.subclass:
            return BaseDataNotice.subclass(*args_, **kwargs_)
        else:
            return BaseDataNotice(*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_land_record(self):
        return self.land_record
    def set_land_record(self, land_record):
        self.land_record = land_record
    def get_room_record(self):
        return self.room_record
    def set_room_record(self, room_record):
        self.room_record = room_record
    def get_car_parking_space_record(self):
        return self.car_parking_space_record
    def set_car_parking_space_record(self, car_parking_space_record):
        self.car_parking_space_record = car_parking_space_record
    def get_property_complex_record(self):
        return self.property_complex_record
    def set_property_complex_record(self, property_complex_record):
        self.property_complex_record = property_complex_record
    def get_unified_real_estate_complex_record(self):
        return self.unified_real_estate_complex_record
    def set_unified_real_estate_complex_record(self, unified_real_estate_complex_record):
        self.unified_real_estate_complex_record = unified_real_estate_complex_record
    def get_object_under_construction_record(self):
        return self.object_under_construction_record
    def set_object_under_construction_record(self, object_under_construction_record):
        self.object_under_construction_record = object_under_construction_record
    def get_build_record(self):
        return self.build_record
    def set_build_record(self, build_record):
        self.build_record = build_record
    def get_construction_record(self):
        return self.construction_record
    def set_construction_record(self, construction_record):
        self.construction_record = construction_record
    def has__content(self):
        if (
            self.land_record is not None or
            self.room_record is not None or
            self.car_parking_space_record is not None or
            self.property_complex_record is not None or
            self.unified_real_estate_complex_record is not None or
            self.object_under_construction_record is not None or
            self.build_record is not None or
            self.construction_record is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BaseDataNotice', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BaseDataNotice')
        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_ == 'BaseDataNotice':
            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_='BaseDataNotice')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BaseDataNotice', 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_='BaseDataNotice'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BaseDataNotice', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.land_record is not None:
            namespaceprefix_ = self.land_record_nsprefix_ + ':' if (UseCapturedNS_ and self.land_record_nsprefix_) else ''
            self.land_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_record', pretty_print=pretty_print)
        if self.room_record is not None:
            namespaceprefix_ = self.room_record_nsprefix_ + ':' if (UseCapturedNS_ and self.room_record_nsprefix_) else ''
            self.room_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_record', pretty_print=pretty_print)
        if self.car_parking_space_record is not None:
            namespaceprefix_ = self.car_parking_space_record_nsprefix_ + ':' if (UseCapturedNS_ and self.car_parking_space_record_nsprefix_) else ''
            self.car_parking_space_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='car_parking_space_record', pretty_print=pretty_print)
        if self.property_complex_record is not None:
            namespaceprefix_ = self.property_complex_record_nsprefix_ + ':' if (UseCapturedNS_ and self.property_complex_record_nsprefix_) else ''
            self.property_complex_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='property_complex_record', pretty_print=pretty_print)
        if self.unified_real_estate_complex_record is not None:
            namespaceprefix_ = self.unified_real_estate_complex_record_nsprefix_ + ':' if (UseCapturedNS_ and self.unified_real_estate_complex_record_nsprefix_) else ''
            self.unified_real_estate_complex_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='unified_real_estate_complex_record', pretty_print=pretty_print)
        if self.object_under_construction_record is not None:
            namespaceprefix_ = self.object_under_construction_record_nsprefix_ + ':' if (UseCapturedNS_ and self.object_under_construction_record_nsprefix_) else ''
            self.object_under_construction_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_under_construction_record', pretty_print=pretty_print)
        if self.build_record is not None:
            namespaceprefix_ = self.build_record_nsprefix_ + ':' if (UseCapturedNS_ and self.build_record_nsprefix_) else ''
            self.build_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='build_record', pretty_print=pretty_print)
        if self.construction_record is not None:
            namespaceprefix_ = self.construction_record_nsprefix_ + ':' if (UseCapturedNS_ and self.construction_record_nsprefix_) else ''
            self.construction_record.export(outfile, level, namespaceprefix_, namespacedef_='', name_='construction_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_record':
            obj_ = DataObject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_record = obj_
            obj_.original_tagname_ = 'land_record'
        elif nodeName_ == 'room_record':
            obj_ = DataObject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_record = obj_
            obj_.original_tagname_ = 'room_record'
        elif nodeName_ == 'car_parking_space_record':
            obj_ = DataObject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.car_parking_space_record = obj_
            obj_.original_tagname_ = 'car_parking_space_record'
        elif nodeName_ == 'property_complex_record':
            obj_ = DataObject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.property_complex_record = obj_
            obj_.original_tagname_ = 'property_complex_record'
        elif nodeName_ == 'unified_real_estate_complex_record':
            obj_ = DataObject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.unified_real_estate_complex_record = obj_
            obj_.original_tagname_ = 'unified_real_estate_complex_record'
        elif nodeName_ == 'object_under_construction_record':
            obj_ = DataObject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_under_construction_record = obj_
            obj_.original_tagname_ = 'object_under_construction_record'
        elif nodeName_ == 'build_record':
            obj_ = DataObject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.build_record = obj_
            obj_.original_tagname_ = 'build_record'
        elif nodeName_ == 'construction_record':
            obj_ = DataObject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.construction_record = obj_
            obj_.original_tagname_ = 'construction_record'
# end class BaseDataNotice


class ObjectType(GeneratedsSuper):
    """ObjectType -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    common_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, common_data=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.common_data = common_data
        self.common_data_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectType.subclass:
            return ObjectType.subclass(*args_, **kwargs_)
        else:
            return ObjectType(*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_common_data(self):
        return self.common_data
    def set_common_data(self, common_data):
        self.common_data = common_data
    def has__content(self):
        if (
            self.common_data is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectType')
        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_ == 'ObjectType':
            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_='ObjectType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectType', 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_='ObjectType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.common_data is not None:
            namespaceprefix_ = self.common_data_nsprefix_ + ':' if (UseCapturedNS_ and self.common_data_nsprefix_) else ''
            self.common_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_data', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'common_data':
            obj_ = CommonDataType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_data = obj_
            obj_.original_tagname_ = 'common_data'
# end class ObjectType


class ObjectSubType(GeneratedsSuper):
    """ObjectSubType -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    common_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    subtype -- В
    и
    д
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, common_data=None, subtype=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.common_data = common_data
        self.common_data_nsprefix_ = None
        self.subtype = subtype
        self.subtype_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectSubType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectSubType.subclass:
            return ObjectSubType.subclass(*args_, **kwargs_)
        else:
            return ObjectSubType(*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_common_data(self):
        return self.common_data
    def set_common_data(self, common_data):
        self.common_data = common_data
    def get_subtype(self):
        return self.subtype
    def set_subtype(self, subtype):
        self.subtype = subtype
    def has__content(self):
        if (
            self.common_data is not None or
            self.subtype is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectSubType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectSubType')
        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_ == 'ObjectSubType':
            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_='ObjectSubType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectSubType', 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_='ObjectSubType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectSubType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.common_data is not None:
            namespaceprefix_ = self.common_data_nsprefix_ + ':' if (UseCapturedNS_ and self.common_data_nsprefix_) else ''
            self.common_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_data', pretty_print=pretty_print)
        if self.subtype is not None:
            namespaceprefix_ = self.subtype_nsprefix_ + ':' if (UseCapturedNS_ and self.subtype_nsprefix_) else ''
            self.subtype.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subtype', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'common_data':
            obj_ = CommonDataType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_data = obj_
            obj_.original_tagname_ = 'common_data'
        elif nodeName_ == 'subtype':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.subtype = obj_
            obj_.original_tagname_ = 'subtype'
# end class ObjectSubType


class ObjectCadNumber(GeneratedsSuper):
    """ObjectCadNumber -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    common_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, common_data=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.common_data = common_data
        self.common_data_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectCadNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectCadNumber.subclass:
            return ObjectCadNumber.subclass(*args_, **kwargs_)
        else:
            return ObjectCadNumber(*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_common_data(self):
        return self.common_data
    def set_common_data(self, common_data):
        self.common_data = common_data
    def has__content(self):
        if (
            self.common_data is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectCadNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectCadNumber')
        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_ == 'ObjectCadNumber':
            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_='ObjectCadNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectCadNumber', 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_='ObjectCadNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectCadNumber', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.common_data is not None:
            namespaceprefix_ = self.common_data_nsprefix_ + ':' if (UseCapturedNS_ and self.common_data_nsprefix_) else ''
            self.common_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_data', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'common_data':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_data = obj_
            obj_.original_tagname_ = 'common_data'
# end class ObjectCadNumber


class ObjectCommonData(GeneratedsSuper):
    """ObjectCommonData -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    common_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, common_data=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.common_data = common_data
        self.common_data_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectCommonData)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectCommonData.subclass:
            return ObjectCommonData.subclass(*args_, **kwargs_)
        else:
            return ObjectCommonData(*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_common_data(self):
        return self.common_data
    def set_common_data(self, common_data):
        self.common_data = common_data
    def has__content(self):
        if (
            self.common_data is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectCommonData', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectCommonData')
        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_ == 'ObjectCommonData':
            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_='ObjectCommonData')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectCommonData', 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_='ObjectCommonData'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectCommonData', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.common_data is not None:
            namespaceprefix_ = self.common_data_nsprefix_ + ':' if (UseCapturedNS_ and self.common_data_nsprefix_) else ''
            self.common_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_data', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'common_data':
            obj_ = CommonData.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_data = obj_
            obj_.original_tagname_ = 'common_data'
# end class ObjectCommonData


class CommonDataType(GeneratedsSuper):
    """CommonDataType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    type -- В
    и
    д
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_=None, cad_number=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.type_ = type_
        self.type__nsprefix_ = None
        self.cad_number = cad_number
        self.cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CommonDataType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CommonDataType.subclass:
            return CommonDataType.subclass(*args_, **kwargs_)
        else:
            return CommonDataType(*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_type(self):
        return self.type_
    def set_type(self, type_):
        self.type_ = type_
    def get_cad_number(self):
        return self.cad_number
    def set_cad_number(self, cad_number):
        self.cad_number = cad_number
    def has__content(self):
        if (
            self.type_ is not None or
            self.cad_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonDataType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CommonDataType')
        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_ == 'CommonDataType':
            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_='CommonDataType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CommonDataType', 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_='CommonDataType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonDataType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_ is not None:
            namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else ''
            self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', pretty_print=pretty_print)
        if self.cad_number is not None:
            namespaceprefix_ = self.cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scad_number>%s</%scad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cad_number), input_name='cad_number')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
        elif nodeName_ == 'cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cad_number')
            value_ = self.gds_validate_string(value_, node, 'cad_number')
            self.cad_number = value_
            self.cad_number_nsprefix_ = child_.prefix
# end class CommonDataType


class CommonData(GeneratedsSuper):
    """CommonData -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    н
    о
    м
    е
    р
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    )
    cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    quarter_cad_number -- Н
    о
    м
    е
    р
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    type -- В
    и
    д
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cad_number=None, quarter_cad_number=None, type_=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.cad_number = cad_number
        self.cad_number_nsprefix_ = None
        self.quarter_cad_number = quarter_cad_number
        self.quarter_cad_number_nsprefix_ = None
        self.type_ = type_
        self.type__nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CommonData)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CommonData.subclass:
            return CommonData.subclass(*args_, **kwargs_)
        else:
            return CommonData(*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_cad_number(self):
        return self.cad_number
    def set_cad_number(self, cad_number):
        self.cad_number = cad_number
    def get_quarter_cad_number(self):
        return self.quarter_cad_number
    def set_quarter_cad_number(self, quarter_cad_number):
        self.quarter_cad_number = quarter_cad_number
    def get_type(self):
        return self.type_
    def set_type(self, type_):
        self.type_ = type_
    def has__content(self):
        if (
            self.cad_number is not None or
            self.quarter_cad_number is not None or
            self.type_ is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonData', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CommonData')
        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_ == 'CommonData':
            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_='CommonData')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CommonData', 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_='CommonData'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonData', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.cad_number is not None:
            namespaceprefix_ = self.cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scad_number>%s</%scad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cad_number), input_name='cad_number')), namespaceprefix_ , eol_))
        if self.quarter_cad_number is not None:
            namespaceprefix_ = self.quarter_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.quarter_cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%squarter_cad_number>%s</%squarter_cad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.quarter_cad_number), input_name='quarter_cad_number')), namespaceprefix_ , eol_))
        if self.type_ is not None:
            namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else ''
            self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cad_number')
            value_ = self.gds_validate_string(value_, node, 'cad_number')
            self.cad_number = value_
            self.cad_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'quarter_cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'quarter_cad_number')
            value_ = self.gds_validate_string(value_, node, 'quarter_cad_number')
            self.quarter_cad_number = value_
            self.quarter_cad_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
# end class CommonData


class CommonDataAll(GeneratedsSuper):
    """CommonDataAll -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    (
    в
    и
    д
    ,
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    н
    о
    м
    е
    р
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    )
    cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    type -- В
    и
    д
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    quarter_cad_number -- Н
    о
    м
    е
    р
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    temporary_info -- С
    в
    е
    д
    е
    н
    и
    я
    н
    о
    с
    я
    т
    в
    р
    е
    м
    е
    н
    н
    ы
    й
    х
    а
    р
    а
    к
    т
    е
    р
    previously_posted -- Р
    а
    н
    е
    е
    у
    ч
    т
    е
    н
    н
    ы
    й
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cad_number=None, type_=None, quarter_cad_number=None, temporary_info=None, previously_posted=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.cad_number = cad_number
        self.cad_number_nsprefix_ = None
        self.type_ = type_
        self.type__nsprefix_ = None
        self.quarter_cad_number = quarter_cad_number
        self.quarter_cad_number_nsprefix_ = None
        self.temporary_info = temporary_info
        self.temporary_info_nsprefix_ = None
        self.previously_posted = previously_posted
        self.previously_posted_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CommonDataAll)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CommonDataAll.subclass:
            return CommonDataAll.subclass(*args_, **kwargs_)
        else:
            return CommonDataAll(*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_cad_number(self):
        return self.cad_number
    def set_cad_number(self, cad_number):
        self.cad_number = cad_number
    def get_type(self):
        return self.type_
    def set_type(self, type_):
        self.type_ = type_
    def get_quarter_cad_number(self):
        return self.quarter_cad_number
    def set_quarter_cad_number(self, quarter_cad_number):
        self.quarter_cad_number = quarter_cad_number
    def get_temporary_info(self):
        return self.temporary_info
    def set_temporary_info(self, temporary_info):
        self.temporary_info = temporary_info
    def get_previously_posted(self):
        return self.previously_posted
    def set_previously_posted(self, previously_posted):
        self.previously_posted = previously_posted
    def has__content(self):
        if (
            self.cad_number is not None or
            self.type_ is not None or
            self.quarter_cad_number is not None or
            self.temporary_info is not None or
            self.previously_posted is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonDataAll', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CommonDataAll')
        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_ == 'CommonDataAll':
            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_='CommonDataAll')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CommonDataAll', 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_='CommonDataAll'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonDataAll', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.cad_number is not None:
            namespaceprefix_ = self.cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scad_number>%s</%scad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cad_number), input_name='cad_number')), namespaceprefix_ , eol_))
        if self.type_ is not None:
            namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else ''
            self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', pretty_print=pretty_print)
        if self.quarter_cad_number is not None:
            namespaceprefix_ = self.quarter_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.quarter_cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%squarter_cad_number>%s</%squarter_cad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.quarter_cad_number), input_name='quarter_cad_number')), namespaceprefix_ , eol_))
        if self.temporary_info is not None:
            namespaceprefix_ = self.temporary_info_nsprefix_ + ':' if (UseCapturedNS_ and self.temporary_info_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stemporary_info>%s</%stemporary_info>%s' % (namespaceprefix_ , self.gds_format_boolean(self.temporary_info, input_name='temporary_info'), namespaceprefix_ , eol_))
        if self.previously_posted is not None:
            namespaceprefix_ = self.previously_posted_nsprefix_ + ':' if (UseCapturedNS_ and self.previously_posted_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spreviously_posted>%s</%spreviously_posted>%s' % (namespaceprefix_ , self.gds_format_boolean(self.previously_posted, input_name='previously_posted'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cad_number')
            value_ = self.gds_validate_string(value_, node, 'cad_number')
            self.cad_number = value_
            self.cad_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
        elif nodeName_ == 'quarter_cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'quarter_cad_number')
            value_ = self.gds_validate_string(value_, node, 'quarter_cad_number')
            self.quarter_cad_number = value_
            self.quarter_cad_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'temporary_info':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'temporary_info')
            ival_ = self.gds_validate_boolean(ival_, node, 'temporary_info')
            self.temporary_info = ival_
            self.temporary_info_nsprefix_ = child_.prefix
        elif nodeName_ == 'previously_posted':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'previously_posted')
            ival_ = self.gds_validate_boolean(ival_, node, 'previously_posted')
            self.previously_posted = ival_
            self.previously_posted_nsprefix_ = child_.prefix
# end class CommonDataAll


class RegistrationDate(GeneratedsSuper):
    """RegistrationDate -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    registration_date -- Д
    а
    т
    а
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, registration_date=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(registration_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(registration_date, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = registration_date
        self.registration_date = initvalue_
        self.registration_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RegistrationDate)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RegistrationDate.subclass:
            return RegistrationDate.subclass(*args_, **kwargs_)
        else:
            return RegistrationDate(*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_registration_date(self):
        return self.registration_date
    def set_registration_date(self, registration_date):
        self.registration_date = registration_date
    def has__content(self):
        if (
            self.registration_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RegistrationDate', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RegistrationDate')
        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_ == 'RegistrationDate':
            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_='RegistrationDate')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RegistrationDate', 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_='RegistrationDate'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RegistrationDate', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.registration_date is not None:
            namespaceprefix_ = self.registration_date_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_date>%s</%sregistration_date>%s' % (namespaceprefix_ , self.gds_format_datetime(self.registration_date, input_name='registration_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'registration_date':
            sval_ = child_.text
            dval_ = self.gds_parse_datetime(sval_)
            self.registration_date = dval_
            self.registration_date_nsprefix_ = child_.prefix
# end class RegistrationDate


class RecordInfo(GeneratedsSuper):
    """RecordInfo -- Д
    а
    т
    ы
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    (
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    /
    с
    н
    я
    т
    и
    я
    с
    у
    ч
    е
    т
    а
    (
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    ))
    registration_date -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    н
    а
    у
    ч
    е
    т
    /
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    cancel_date -- Д
    а
    т
    а
    с
    н
    я
    т
    и
    я
    с
    у
    ч
    е
    т
    а
    /
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, registration_date=None, cancel_date=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(registration_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(registration_date, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = registration_date
        self.registration_date = initvalue_
        self.registration_date_nsprefix_ = None
        if isinstance(cancel_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(cancel_date, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = cancel_date
        self.cancel_date = initvalue_
        self.cancel_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RecordInfo)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RecordInfo.subclass:
            return RecordInfo.subclass(*args_, **kwargs_)
        else:
            return RecordInfo(*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_registration_date(self):
        return self.registration_date
    def set_registration_date(self, registration_date):
        self.registration_date = registration_date
    def get_cancel_date(self):
        return self.cancel_date
    def set_cancel_date(self, cancel_date):
        self.cancel_date = cancel_date
    def has__content(self):
        if (
            self.registration_date is not None or
            self.cancel_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RecordInfo', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RecordInfo')
        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_ == 'RecordInfo':
            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_='RecordInfo')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RecordInfo', 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_='RecordInfo'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RecordInfo', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.registration_date is not None:
            namespaceprefix_ = self.registration_date_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_date>%s</%sregistration_date>%s' % (namespaceprefix_ , self.gds_format_datetime(self.registration_date, input_name='registration_date'), namespaceprefix_ , eol_))
        if self.cancel_date is not None:
            namespaceprefix_ = self.cancel_date_nsprefix_ + ':' if (UseCapturedNS_ and self.cancel_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scancel_date>%s</%scancel_date>%s' % (namespaceprefix_ , self.gds_format_datetime(self.cancel_date, input_name='cancel_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'registration_date':
            sval_ = child_.text
            dval_ = self.gds_parse_datetime(sval_)
            self.registration_date = dval_
            self.registration_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'cancel_date':
            sval_ = child_.text
            dval_ = self.gds_parse_datetime(sval_)
            self.cancel_date = dval_
            self.cancel_date_nsprefix_ = child_.prefix
# end class RecordInfo


class RecordInfoDate(GeneratedsSuper):
    """RecordInfoDate -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    н
    а
    у
    ч
    е
    т
    registration_date -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    н
    а
    у
    ч
    е
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, registration_date=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(registration_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(registration_date, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = registration_date
        self.registration_date = initvalue_
        self.registration_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RecordInfoDate)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RecordInfoDate.subclass:
            return RecordInfoDate.subclass(*args_, **kwargs_)
        else:
            return RecordInfoDate(*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_registration_date(self):
        return self.registration_date
    def set_registration_date(self, registration_date):
        self.registration_date = registration_date
    def has__content(self):
        if (
            self.registration_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RecordInfoDate', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RecordInfoDate')
        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_ == 'RecordInfoDate':
            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_='RecordInfoDate')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RecordInfoDate', 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_='RecordInfoDate'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RecordInfoDate', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.registration_date is not None:
            namespaceprefix_ = self.registration_date_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_date>%s</%sregistration_date>%s' % (namespaceprefix_ , self.gds_format_datetime(self.registration_date, input_name='registration_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'registration_date':
            sval_ = child_.text
            dval_ = self.gds_parse_datetime(sval_)
            self.registration_date = dval_
            self.registration_date_nsprefix_ = child_.prefix
# end class RecordInfoDate


class CancelDate(GeneratedsSuper):
    """CancelDate -- Д
    а
    т
    а
    з
    а
    к
    р
    ы
    т
    и
    я
    р
    а
    з
    д
    е
    л
    а
    (
    д
    а
    т
    а
    с
    н
    я
    т
    и
    я
    с
    у
    ч
    е
    т
    а
    /
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    )
    cancel_date -- Д
    а
    т
    а
    с
    н
    я
    т
    и
    я
    с
    у
    ч
    е
    т
    а
    /
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cancel_date=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(cancel_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(cancel_date, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = cancel_date
        self.cancel_date = initvalue_
        self.cancel_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CancelDate)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CancelDate.subclass:
            return CancelDate.subclass(*args_, **kwargs_)
        else:
            return CancelDate(*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_cancel_date(self):
        return self.cancel_date
    def set_cancel_date(self, cancel_date):
        self.cancel_date = cancel_date
    def has__content(self):
        if (
            self.cancel_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CancelDate', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CancelDate')
        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_ == 'CancelDate':
            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_='CancelDate')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CancelDate', 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_='CancelDate'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CancelDate', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.cancel_date is not None:
            namespaceprefix_ = self.cancel_date_nsprefix_ + ':' if (UseCapturedNS_ and self.cancel_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scancel_date>%s</%scancel_date>%s' % (namespaceprefix_ , self.gds_format_datetime(self.cancel_date, input_name='cancel_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cancel_date':
            sval_ = child_.text
            dval_ = self.gds_parse_datetime(sval_)
            self.cancel_date = dval_
            self.cancel_date_nsprefix_ = child_.prefix
# end class CancelDate


class RecordInfoAllDates(GeneratedsSuper):
    """RecordInfoAllDates -- Д
    а
    т
    ы
    в
    н
    е
    с
    е
    н
    и
    я
    ,
    и
    з
    м
    е
    н
    е
    н
    и
    я
    ,
    и
    с
    к
    л
    ю
    ч
    е
    н
    и
    я
    с
    в
    е
    д
    е
    н
    и
    й
    registration_date -- Д
    а
    т
    а
    в
    н
    е
    с
    е
    н
    и
    я
    с
    в
    е
    д
    е
    н
    и
    й
    (
    д
    а
    т
    а
    п
    р
    и
    с
    в
    о
    е
    н
    и
    я
    н
    о
    м
    е
    р
    а
    )
    dates_changes -- Д
    а
    т
    ы
    и
    з
    м
    е
    н
    е
    н
    и
    й
    с
    в
    е
    д
    е
    н
    и
    й
    cancel_date -- Д
    а
    т
    а
    и
    с
    к
    л
    ю
    ч
    е
    н
    и
    я
    с
    в
    е
    д
    е
    н
    и
    й
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, registration_date=None, dates_changes=None, cancel_date=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(registration_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(registration_date, '%Y-%m-%d').date()
        else:
            initvalue_ = registration_date
        self.registration_date = initvalue_
        self.registration_date_nsprefix_ = None
        self.dates_changes = dates_changes
        self.dates_changes_nsprefix_ = None
        if isinstance(cancel_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(cancel_date, '%Y-%m-%d').date()
        else:
            initvalue_ = cancel_date
        self.cancel_date = initvalue_
        self.cancel_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RecordInfoAllDates)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RecordInfoAllDates.subclass:
            return RecordInfoAllDates.subclass(*args_, **kwargs_)
        else:
            return RecordInfoAllDates(*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_registration_date(self):
        return self.registration_date
    def set_registration_date(self, registration_date):
        self.registration_date = registration_date
    def get_dates_changes(self):
        return self.dates_changes
    def set_dates_changes(self, dates_changes):
        self.dates_changes = dates_changes
    def get_cancel_date(self):
        return self.cancel_date
    def set_cancel_date(self, cancel_date):
        self.cancel_date = cancel_date
    def has__content(self):
        if (
            self.registration_date is not None or
            self.dates_changes is not None or
            self.cancel_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RecordInfoAllDates', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RecordInfoAllDates')
        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_ == 'RecordInfoAllDates':
            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_='RecordInfoAllDates')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RecordInfoAllDates', 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_='RecordInfoAllDates'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RecordInfoAllDates', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.registration_date is not None:
            namespaceprefix_ = self.registration_date_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_date>%s</%sregistration_date>%s' % (namespaceprefix_ , self.gds_format_date(self.registration_date, input_name='registration_date'), namespaceprefix_ , eol_))
        if self.dates_changes is not None:
            namespaceprefix_ = self.dates_changes_nsprefix_ + ':' if (UseCapturedNS_ and self.dates_changes_nsprefix_) else ''
            self.dates_changes.export(outfile, level, namespaceprefix_, namespacedef_='', name_='dates_changes', pretty_print=pretty_print)
        if self.cancel_date is not None:
            namespaceprefix_ = self.cancel_date_nsprefix_ + ':' if (UseCapturedNS_ and self.cancel_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scancel_date>%s</%scancel_date>%s' % (namespaceprefix_ , self.gds_format_date(self.cancel_date, input_name='cancel_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'registration_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.registration_date = dval_
            self.registration_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'dates_changes':
            obj_ = DatesChanges.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.dates_changes = obj_
            obj_.original_tagname_ = 'dates_changes'
        elif nodeName_ == 'cancel_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.cancel_date = dval_
            self.cancel_date_nsprefix_ = child_.prefix
# end class RecordInfoAllDates


class DatesChanges(GeneratedsSuper):
    """DatesChanges -- Д
    а
    т
    ы
    и
    з
    м
    е
    н
    е
    н
    и
    й
    с
    в
    е
    д
    е
    н
    и
    й
    date_change -- Д
    а
    т
    а
    и
    з
    м
    е
    н
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, date_change=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 date_change is None:
            self.date_change = []
        else:
            self.date_change = date_change
        self.date_change_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DatesChanges)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DatesChanges.subclass:
            return DatesChanges.subclass(*args_, **kwargs_)
        else:
            return DatesChanges(*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_date_change(self):
        return self.date_change
    def set_date_change(self, date_change):
        self.date_change = date_change
    def add_date_change(self, value):
        self.date_change.append(value)
    def insert_date_change_at(self, index, value):
        self.date_change.insert(index, value)
    def replace_date_change_at(self, index, value):
        self.date_change[index] = value
    def has__content(self):
        if (
            self.date_change
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DatesChanges', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DatesChanges')
        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_ == 'DatesChanges':
            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_='DatesChanges')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DatesChanges', 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_='DatesChanges'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DatesChanges', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for date_change_ in self.date_change:
            namespaceprefix_ = self.date_change_nsprefix_ + ':' if (UseCapturedNS_ and self.date_change_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_change>%s</%sdate_change>%s' % (namespaceprefix_ , self.gds_format_date(date_change_, input_name='date_change'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'date_change':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_change.append(dval_)
            self.date_change_nsprefix_ = child_.prefix
# end class DatesChanges


class RegNumberBorder(GeneratedsSuper):
    """RegNumberBorder -- Р
    е
    е
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    г
    р
    а
    н
    и
    ц
    ы
    (reg_number)
    reg_number -- Н
    о
    м
    е
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, reg_number=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.reg_number = reg_number
        self.reg_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RegNumberBorder)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RegNumberBorder.subclass:
            return RegNumberBorder.subclass(*args_, **kwargs_)
        else:
            return RegNumberBorder(*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_reg_number(self):
        return self.reg_number
    def set_reg_number(self, reg_number):
        self.reg_number = reg_number
    def has__content(self):
        if (
            self.reg_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RegNumberBorder', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RegNumberBorder')
        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_ == 'RegNumberBorder':
            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_='RegNumberBorder')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RegNumberBorder', 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_='RegNumberBorder'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RegNumberBorder', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.reg_number is not None:
            namespaceprefix_ = self.reg_number_nsprefix_ + ':' if (UseCapturedNS_ and self.reg_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreg_number>%s</%sreg_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.reg_number), input_name='reg_number')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'reg_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'reg_number')
            value_ = self.gds_validate_string(value_, node, 'reg_number')
            self.reg_number = value_
            self.reg_number_nsprefix_ = child_.prefix
# end class RegNumberBorder


class RegNumbBorder(GeneratedsSuper):
    """RegNumbBorder -- Р
    е
    е
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    г
    р
    а
    н
    и
    ц
    ы
    (reg_numb_border)
    reg_numb_border -- Р
    е
    е
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    г
    р
    а
    н
    и
    ц
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, reg_numb_border=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.reg_numb_border = reg_numb_border
        self.reg_numb_border_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RegNumbBorder)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RegNumbBorder.subclass:
            return RegNumbBorder.subclass(*args_, **kwargs_)
        else:
            return RegNumbBorder(*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_reg_numb_border(self):
        return self.reg_numb_border
    def set_reg_numb_border(self, reg_numb_border):
        self.reg_numb_border = reg_numb_border
    def has__content(self):
        if (
            self.reg_numb_border is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RegNumbBorder', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RegNumbBorder')
        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_ == 'RegNumbBorder':
            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_='RegNumbBorder')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RegNumbBorder', 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_='RegNumbBorder'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RegNumbBorder', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.reg_numb_border is not None:
            namespaceprefix_ = self.reg_numb_border_nsprefix_ + ':' if (UseCapturedNS_ and self.reg_numb_border_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreg_numb_border>%s</%sreg_numb_border>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.reg_numb_border), input_name='reg_numb_border')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'reg_numb_border':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'reg_numb_border')
            value_ = self.gds_validate_string(value_, node, 'reg_numb_border')
            self.reg_numb_border = value_
            self.reg_numb_border_nsprefix_ = child_.prefix
# end class RegNumbBorder


class OldNumbers(GeneratedsSuper):
    """OldNumbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    old_number -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    й
    н
    о
    м
    е
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, old_number=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 old_number is None:
            self.old_number = []
        else:
            self.old_number = old_number
        self.old_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OldNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OldNumbers.subclass:
            return OldNumbers.subclass(*args_, **kwargs_)
        else:
            return OldNumbers(*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_old_number(self):
        return self.old_number
    def set_old_number(self, old_number):
        self.old_number = old_number
    def add_old_number(self, value):
        self.old_number.append(value)
    def insert_old_number_at(self, index, value):
        self.old_number.insert(index, value)
    def replace_old_number_at(self, index, value):
        self.old_number[index] = value
    def has__content(self):
        if (
            self.old_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OldNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OldNumbers')
        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_ == 'OldNumbers':
            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_='OldNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OldNumbers', 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_='OldNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OldNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for old_number_ in self.old_number:
            namespaceprefix_ = self.old_number_nsprefix_ + ':' if (UseCapturedNS_ and self.old_number_nsprefix_) else ''
            old_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'old_number':
            obj_ = OldNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_number.append(obj_)
            obj_.original_tagname_ = 'old_number'
# end class OldNumbers


class OldNumber(GeneratedsSuper):
    """OldNumber -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    й
    н
    о
    м
    е
    р
    number_type -- В
    и
    д
    н
    о
    м
    е
    р
    а
      
    * number -- Н
      о
      м
      е
      р
      
    * assignment_date -- Д
      а
      т
      а
      п
      р
      и
      с
      в
      о
      е
      н
      и
      я
    * assigner -- О
      р
      г
      а
      н
      и
      з
      а
      ц
      и
      я
      ,
      п
      р
      и
      с
      в
      о
      и
      в
      ш
      а
      я
      н
      о
      м
      е
      р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_type=None, number=None, assignment_date=None, assigner=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.number_type = number_type
        self.number_type_nsprefix_ = None
        self.number = number
        self.number_nsprefix_ = None
        if isinstance(assignment_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(assignment_date, '%Y-%m-%d').date()
        else:
            initvalue_ = assignment_date
        self.assignment_date = initvalue_
        self.assignment_date_nsprefix_ = None
        self.assigner = assigner
        self.validate_MultiLiner(self.assigner)
        self.assigner_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OldNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OldNumber.subclass:
            return OldNumber.subclass(*args_, **kwargs_)
        else:
            return OldNumber(*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_type(self):
        return self.number_type
    def set_number_type(self, number_type):
        self.number_type = number_type
    def get_number(self):
        return self.number
    def set_number(self, number):
        self.number = number
    def get_assignment_date(self):
        return self.assignment_date
    def set_assignment_date(self, assignment_date):
        self.assignment_date = assignment_date
    def get_assigner(self):
        return self.assigner
    def set_assigner(self, assigner):
        self.assigner = assigner
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.number_type is not None or
            self.number is not None or
            self.assignment_date is not None or
            self.assigner is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OldNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OldNumber')
        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_ == 'OldNumber':
            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_='OldNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OldNumber', 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_='OldNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OldNumber', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_type is not None:
            namespaceprefix_ = self.number_type_nsprefix_ + ':' if (UseCapturedNS_ and self.number_type_nsprefix_) else ''
            self.number_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='number_type', pretty_print=pretty_print)
        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.assignment_date is not None:
            namespaceprefix_ = self.assignment_date_nsprefix_ + ':' if (UseCapturedNS_ and self.assignment_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sassignment_date>%s</%sassignment_date>%s' % (namespaceprefix_ , self.gds_format_date(self.assignment_date, input_name='assignment_date'), namespaceprefix_ , eol_))
        if self.assigner is not None:
            namespaceprefix_ = self.assigner_nsprefix_ + ':' if (UseCapturedNS_ and self.assigner_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sassigner>%s</%sassigner>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.assigner), input_name='assigner')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.number_type = obj_
            obj_.original_tagname_ = 'number_type'
        elif 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_ == 'assignment_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.assignment_date = dval_
            self.assignment_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'assigner':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'assigner')
            value_ = self.gds_validate_string(value_, node, 'assigner')
            self.assigner = value_
            self.assigner_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.assigner)
# end class OldNumber


class RightNumber(GeneratedsSuper):
    """RightNumber -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    right_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_number=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.right_number = right_number
        self.right_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightNumber.subclass:
            return RightNumber.subclass(*args_, **kwargs_)
        else:
            return RightNumber(*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_right_number(self):
        return self.right_number
    def set_right_number(self, right_number):
        self.right_number = right_number
    def has__content(self):
        if (
            self.right_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightNumber')
        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_ == 'RightNumber':
            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_='RightNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightNumber', 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_='RightNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightNumber', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.right_number is not None:
            namespaceprefix_ = self.right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.right_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sright_number>%s</%sright_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.right_number), input_name='right_number')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'right_number')
            value_ = self.gds_validate_string(value_, node, 'right_number')
            self.right_number = value_
            self.right_number_nsprefix_ = child_.prefix
# end class RightNumber


class RegNumberBorderZone(GeneratedsSuper):
    """RegNumberBorderZone -- Р
    е
    е
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    з
    о
    н
    ы
    (number)
    number -- Н
    о
    м
    е
    р
    з
    о
    н
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number=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.number = number
        self.number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RegNumberBorderZone)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RegNumberBorderZone.subclass:
            return RegNumberBorderZone.subclass(*args_, **kwargs_)
        else:
            return RegNumberBorderZone(*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 has__content(self):
        if (
            self.number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RegNumberBorderZone', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RegNumberBorderZone')
        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_ == 'RegNumberBorderZone':
            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_='RegNumberBorderZone')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RegNumberBorderZone', 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_='RegNumberBorderZone'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RegNumberBorderZone', 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_))
    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):
        pass
    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
# end class RegNumberBorderZone


class RegisteredRight(GeneratedsSuper):
    """RegisteredRight -- З
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    е
    п
    р
    а
    в
    о
    (
    н
    о
    м
    е
    р
    ,
    д
    а
    т
    а
    )
    right_number -- Н
    о
    м
    е
    р
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    р
    а
    в
    а
    registration_date -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    в
    е
    щ
    н
    о
    г
    о
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_number=None, registration_date=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.right_number = right_number
        self.right_number_nsprefix_ = None
        if isinstance(registration_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(registration_date, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = registration_date
        self.registration_date = initvalue_
        self.registration_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RegisteredRight)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RegisteredRight.subclass:
            return RegisteredRight.subclass(*args_, **kwargs_)
        else:
            return RegisteredRight(*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_right_number(self):
        return self.right_number
    def set_right_number(self, right_number):
        self.right_number = right_number
    def get_registration_date(self):
        return self.registration_date
    def set_registration_date(self, registration_date):
        self.registration_date = registration_date
    def validate_dateTimeWithUserTZ(self, value):
        result = True
        # Validate type dateTimeWithUserTZ, a restriction on xs:dateTime.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.right_number is not None or
            self.registration_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RegisteredRight', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RegisteredRight')
        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_ == 'RegisteredRight':
            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_='RegisteredRight')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RegisteredRight', 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_='RegisteredRight'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RegisteredRight', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.right_number is not None:
            namespaceprefix_ = self.right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.right_number_nsprefix_) else ''
            self.right_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_number', pretty_print=pretty_print)
        if self.registration_date is not None:
            namespaceprefix_ = self.registration_date_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_date>%s</%sregistration_date>%s' % (namespaceprefix_ , self.gds_format_datetime(self.registration_date, input_name='registration_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_number':
            obj_ = RightRecordNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_number = obj_
            obj_.original_tagname_ = 'right_number'
        elif nodeName_ == 'registration_date':
            sval_ = child_.text
            dval_ = self.gds_parse_datetime(sval_)
            self.registration_date = dval_
            self.registration_date_nsprefix_ = child_.prefix
            # validate type dateTimeWithUserTZ
            self.validate_dateTimeWithUserTZ(self.registration_date)
# end class RegisteredRight


class Registration(GeneratedsSuper):
    """Registration -- Н
    о
    м
    е
    р
    и
    д
    а
    т
    а
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    restriction_encumbrance_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    /
    р
    е
    е
    с
    т
    р
    о
    в
    о
    й
    з
    а
    п
    и
    с
    и
    registration_date -- Д
    а
    т
    а
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restriction_encumbrance_number=None, registration_date=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.restriction_encumbrance_number = restriction_encumbrance_number
        self.restriction_encumbrance_number_nsprefix_ = None
        if isinstance(registration_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(registration_date, '%Y-%m-%d').date()
        else:
            initvalue_ = registration_date
        self.registration_date = initvalue_
        self.registration_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Registration)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Registration.subclass:
            return Registration.subclass(*args_, **kwargs_)
        else:
            return Registration(*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_restriction_encumbrance_number(self):
        return self.restriction_encumbrance_number
    def set_restriction_encumbrance_number(self, restriction_encumbrance_number):
        self.restriction_encumbrance_number = restriction_encumbrance_number
    def get_registration_date(self):
        return self.registration_date
    def set_registration_date(self, registration_date):
        self.registration_date = registration_date
    def has__content(self):
        if (
            self.restriction_encumbrance_number is not None or
            self.registration_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Registration', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Registration')
        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_ == 'Registration':
            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_='Registration')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Registration', 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_='Registration'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Registration', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.restriction_encumbrance_number is not None:
            namespaceprefix_ = self.restriction_encumbrance_number_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_number_nsprefix_) else ''
            self.restriction_encumbrance_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restriction_encumbrance_number', pretty_print=pretty_print)
        if self.registration_date is not None:
            namespaceprefix_ = self.registration_date_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_date>%s</%sregistration_date>%s' % (namespaceprefix_ , self.gds_format_date(self.registration_date, input_name='registration_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restriction_encumbrance_number':
            obj_ = RestrictRecordNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restriction_encumbrance_number = obj_
            obj_.original_tagname_ = 'restriction_encumbrance_number'
        elif nodeName_ == 'registration_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.registration_date = dval_
            self.registration_date_nsprefix_ = child_.prefix
# end class Registration


class CadLinks(GeneratedsSuper):
    """CadLinks -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    land_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    и
    н
    ы
    х
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ),
    в
    п
    р
    е
    д
    е
    л
    а
    х
    к
    о
    т
    о
    р
    ы
    х
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    room_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    car_parking_space_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_cad_numbers=None, room_cad_numbers=None, car_parking_space_cad_numbers=None, old_numbers=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.land_cad_numbers = land_cad_numbers
        self.land_cad_numbers_nsprefix_ = None
        self.room_cad_numbers = room_cad_numbers
        self.room_cad_numbers_nsprefix_ = None
        self.car_parking_space_cad_numbers = car_parking_space_cad_numbers
        self.car_parking_space_cad_numbers_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinks)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinks.subclass:
            return CadLinks.subclass(*args_, **kwargs_)
        else:
            return CadLinks(*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_land_cad_numbers(self):
        return self.land_cad_numbers
    def set_land_cad_numbers(self, land_cad_numbers):
        self.land_cad_numbers = land_cad_numbers
    def get_room_cad_numbers(self):
        return self.room_cad_numbers
    def set_room_cad_numbers(self, room_cad_numbers):
        self.room_cad_numbers = room_cad_numbers
    def get_car_parking_space_cad_numbers(self):
        return self.car_parking_space_cad_numbers
    def set_car_parking_space_cad_numbers(self, car_parking_space_cad_numbers):
        self.car_parking_space_cad_numbers = car_parking_space_cad_numbers
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def has__content(self):
        if (
            self.land_cad_numbers is not None or
            self.room_cad_numbers is not None or
            self.car_parking_space_cad_numbers is not None or
            self.old_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinks', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinks')
        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_ == 'CadLinks':
            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_='CadLinks')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinks', 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_='CadLinks'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinks', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.land_cad_numbers is not None:
            namespaceprefix_ = self.land_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.land_cad_numbers_nsprefix_) else ''
            self.land_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_cad_numbers', pretty_print=pretty_print)
        if self.room_cad_numbers is not None:
            namespaceprefix_ = self.room_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.room_cad_numbers_nsprefix_) else ''
            self.room_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_cad_numbers', pretty_print=pretty_print)
        if self.car_parking_space_cad_numbers is not None:
            namespaceprefix_ = self.car_parking_space_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.car_parking_space_cad_numbers_nsprefix_) else ''
            self.car_parking_space_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='car_parking_space_cad_numbers', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_cad_numbers':
            obj_ = LandCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_cad_numbers = obj_
            obj_.original_tagname_ = 'land_cad_numbers'
        elif nodeName_ == 'room_cad_numbers':
            obj_ = RoomCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_cad_numbers = obj_
            obj_.original_tagname_ = 'room_cad_numbers'
        elif nodeName_ == 'car_parking_space_cad_numbers':
            obj_ = CarParkingPlaceCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.car_parking_space_cad_numbers = obj_
            obj_.original_tagname_ = 'car_parking_space_cad_numbers'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
# end class CadLinks


class CadLinksAll(GeneratedsSuper):
    """CadLinksAll -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    ascendant_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    и
    з
    к
    о
    т
    о
    р
    ы
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    д
    а
    н
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    descendant_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    о
    б
    р
    а
    з
    о
    в
    а
    н
    н
    ы
    х
    и
    з
    д
    а
    н
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    land_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    и
    н
    ы
    х
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ),
    в
    п
    р
    е
    д
    е
    л
    а
    х
    к
    о
    т
    о
    р
    ы
    х
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    room_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    car_parking_space_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    facility_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    united_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ascendant_cad_numbers=None, descendant_cad_numbers=None, land_cad_numbers=None, room_cad_numbers=None, car_parking_space_cad_numbers=None, facility_cad_number=None, united_cad_number=None, old_numbers=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.ascendant_cad_numbers = ascendant_cad_numbers
        self.ascendant_cad_numbers_nsprefix_ = None
        self.descendant_cad_numbers = descendant_cad_numbers
        self.descendant_cad_numbers_nsprefix_ = None
        self.land_cad_numbers = land_cad_numbers
        self.land_cad_numbers_nsprefix_ = None
        self.room_cad_numbers = room_cad_numbers
        self.room_cad_numbers_nsprefix_ = None
        self.car_parking_space_cad_numbers = car_parking_space_cad_numbers
        self.car_parking_space_cad_numbers_nsprefix_ = None
        self.facility_cad_number = facility_cad_number
        self.facility_cad_number_nsprefix_ = None
        self.united_cad_number = united_cad_number
        self.united_cad_number_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksAll)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksAll.subclass:
            return CadLinksAll.subclass(*args_, **kwargs_)
        else:
            return CadLinksAll(*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_ascendant_cad_numbers(self):
        return self.ascendant_cad_numbers
    def set_ascendant_cad_numbers(self, ascendant_cad_numbers):
        self.ascendant_cad_numbers = ascendant_cad_numbers
    def get_descendant_cad_numbers(self):
        return self.descendant_cad_numbers
    def set_descendant_cad_numbers(self, descendant_cad_numbers):
        self.descendant_cad_numbers = descendant_cad_numbers
    def get_land_cad_numbers(self):
        return self.land_cad_numbers
    def set_land_cad_numbers(self, land_cad_numbers):
        self.land_cad_numbers = land_cad_numbers
    def get_room_cad_numbers(self):
        return self.room_cad_numbers
    def set_room_cad_numbers(self, room_cad_numbers):
        self.room_cad_numbers = room_cad_numbers
    def get_car_parking_space_cad_numbers(self):
        return self.car_parking_space_cad_numbers
    def set_car_parking_space_cad_numbers(self, car_parking_space_cad_numbers):
        self.car_parking_space_cad_numbers = car_parking_space_cad_numbers
    def get_facility_cad_number(self):
        return self.facility_cad_number
    def set_facility_cad_number(self, facility_cad_number):
        self.facility_cad_number = facility_cad_number
    def get_united_cad_number(self):
        return self.united_cad_number
    def set_united_cad_number(self, united_cad_number):
        self.united_cad_number = united_cad_number
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def has__content(self):
        if (
            self.ascendant_cad_numbers is not None or
            self.descendant_cad_numbers is not None or
            self.land_cad_numbers is not None or
            self.room_cad_numbers is not None or
            self.car_parking_space_cad_numbers is not None or
            self.facility_cad_number is not None or
            self.united_cad_number is not None or
            self.old_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksAll', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksAll')
        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_ == 'CadLinksAll':
            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_='CadLinksAll')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksAll', 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_='CadLinksAll'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksAll', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ascendant_cad_numbers is not None:
            namespaceprefix_ = self.ascendant_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.ascendant_cad_numbers_nsprefix_) else ''
            self.ascendant_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ascendant_cad_numbers', pretty_print=pretty_print)
        if self.descendant_cad_numbers is not None:
            namespaceprefix_ = self.descendant_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.descendant_cad_numbers_nsprefix_) else ''
            self.descendant_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='descendant_cad_numbers', pretty_print=pretty_print)
        if self.land_cad_numbers is not None:
            namespaceprefix_ = self.land_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.land_cad_numbers_nsprefix_) else ''
            self.land_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_cad_numbers', pretty_print=pretty_print)
        if self.room_cad_numbers is not None:
            namespaceprefix_ = self.room_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.room_cad_numbers_nsprefix_) else ''
            self.room_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_cad_numbers', pretty_print=pretty_print)
        if self.car_parking_space_cad_numbers is not None:
            namespaceprefix_ = self.car_parking_space_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.car_parking_space_cad_numbers_nsprefix_) else ''
            self.car_parking_space_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='car_parking_space_cad_numbers', pretty_print=pretty_print)
        if self.facility_cad_number is not None:
            namespaceprefix_ = self.facility_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.facility_cad_number_nsprefix_) else ''
            self.facility_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='facility_cad_number', pretty_print=pretty_print)
        if self.united_cad_number is not None:
            namespaceprefix_ = self.united_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.united_cad_number_nsprefix_) else ''
            self.united_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='united_cad_number', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ascendant_cad_numbers':
            obj_ = AscendantCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ascendant_cad_numbers = obj_
            obj_.original_tagname_ = 'ascendant_cad_numbers'
        elif nodeName_ == 'descendant_cad_numbers':
            obj_ = DescendantCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.descendant_cad_numbers = obj_
            obj_.original_tagname_ = 'descendant_cad_numbers'
        elif nodeName_ == 'land_cad_numbers':
            obj_ = LandCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_cad_numbers = obj_
            obj_.original_tagname_ = 'land_cad_numbers'
        elif nodeName_ == 'room_cad_numbers':
            obj_ = RoomCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_cad_numbers = obj_
            obj_.original_tagname_ = 'room_cad_numbers'
        elif nodeName_ == 'car_parking_space_cad_numbers':
            obj_ = CarParkingPlaceCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.car_parking_space_cad_numbers = obj_
            obj_.original_tagname_ = 'car_parking_space_cad_numbers'
        elif nodeName_ == 'facility_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.facility_cad_number = obj_
            obj_.original_tagname_ = 'facility_cad_number'
        elif nodeName_ == 'united_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.united_cad_number = obj_
            obj_.original_tagname_ = 'united_cad_number'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
# end class CadLinksAll


class CadLinkRestrictions(GeneratedsSuper):
    """CadLinkRestrictions -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    reg_number_border -- Р
    е
    е
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    з
    о
    н
    ы
    easement_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    ,
    д
    л
    я
    к
    о
    т
    о
    р
    о
    г
    о
    о
    б
    е
    с
    п
    е
    ч
    е
    н
    п
    р
    о
    х
    о
    д
    (
    п
    р
    о
    е
    з
    д
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, reg_number_border=None, easement_cad_numbers=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.reg_number_border = reg_number_border
        self.reg_number_border_nsprefix_ = None
        self.easement_cad_numbers = easement_cad_numbers
        self.easement_cad_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinkRestrictions)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinkRestrictions.subclass:
            return CadLinkRestrictions.subclass(*args_, **kwargs_)
        else:
            return CadLinkRestrictions(*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_reg_number_border(self):
        return self.reg_number_border
    def set_reg_number_border(self, reg_number_border):
        self.reg_number_border = reg_number_border
    def get_easement_cad_numbers(self):
        return self.easement_cad_numbers
    def set_easement_cad_numbers(self, easement_cad_numbers):
        self.easement_cad_numbers = easement_cad_numbers
    def has__content(self):
        if (
            self.reg_number_border is not None or
            self.easement_cad_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinkRestrictions', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinkRestrictions')
        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_ == 'CadLinkRestrictions':
            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_='CadLinkRestrictions')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinkRestrictions', 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_='CadLinkRestrictions'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinkRestrictions', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.reg_number_border is not None:
            namespaceprefix_ = self.reg_number_border_nsprefix_ + ':' if (UseCapturedNS_ and self.reg_number_border_nsprefix_) else ''
            self.reg_number_border.export(outfile, level, namespaceprefix_, namespacedef_='', name_='reg_number_border', pretty_print=pretty_print)
        if self.easement_cad_numbers is not None:
            namespaceprefix_ = self.easement_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.easement_cad_numbers_nsprefix_) else ''
            self.easement_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='easement_cad_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'reg_number_border':
            obj_ = RegNumberBorderZone.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.reg_number_border = obj_
            obj_.original_tagname_ = 'reg_number_border'
        elif nodeName_ == 'easement_cad_numbers':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.easement_cad_numbers = obj_
            obj_.original_tagname_ = 'easement_cad_numbers'
# end class CadLinkRestrictions


class CadLinksRoom(GeneratedsSuper):
    """CadLinksRoom -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    (
    п
    о
    м
    е
    щ
    е
    н
    и
    е
    ))
    parent_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    д
    а
    н
    и
    я
    ,
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    ),
    в
    п
    р
    е
    д
    е
    л
    а
    х
    к
    о
    т
    о
    р
    о
    г
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    е
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    parent_room_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    к
    в
    а
    р
    т
    и
    р
    ы
    ,
    в
    к
    о
    т
    о
    р
    о
    м
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    а
    к
    о
    м
    н
    а
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, parent_cad_number=None, old_numbers=None, parent_room_cad_number=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.parent_cad_number = parent_cad_number
        self.parent_cad_number_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
        self.parent_room_cad_number = parent_room_cad_number
        self.parent_room_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksRoom)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksRoom.subclass:
            return CadLinksRoom.subclass(*args_, **kwargs_)
        else:
            return CadLinksRoom(*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_parent_cad_number(self):
        return self.parent_cad_number
    def set_parent_cad_number(self, parent_cad_number):
        self.parent_cad_number = parent_cad_number
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def get_parent_room_cad_number(self):
        return self.parent_room_cad_number
    def set_parent_room_cad_number(self, parent_room_cad_number):
        self.parent_room_cad_number = parent_room_cad_number
    def has__content(self):
        if (
            self.parent_cad_number is not None or
            self.old_numbers is not None or
            self.parent_room_cad_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksRoom', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksRoom')
        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_ == 'CadLinksRoom':
            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_='CadLinksRoom')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksRoom', 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_='CadLinksRoom'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksRoom', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.parent_cad_number is not None:
            namespaceprefix_ = self.parent_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.parent_cad_number_nsprefix_) else ''
            self.parent_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parent_cad_number', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', pretty_print=pretty_print)
        if self.parent_room_cad_number is not None:
            namespaceprefix_ = self.parent_room_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.parent_room_cad_number_nsprefix_) else ''
            self.parent_room_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parent_room_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'parent_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.parent_cad_number = obj_
            obj_.original_tagname_ = 'parent_cad_number'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
        elif nodeName_ == 'parent_room_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.parent_room_cad_number = obj_
            obj_.original_tagname_ = 'parent_room_cad_number'
# end class CadLinksRoom


class CadLinksRoomAll(GeneratedsSuper):
    """CadLinksRoomAll -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    ascendant_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    и
    з
    к
    о
    т
    о
    р
    ы
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    д
    а
    н
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    descendant_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    о
    б
    р
    а
    з
    о
    в
    а
    н
    н
    ы
    х
    и
    з
    д
    а
    н
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    parent_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    д
    а
    н
    и
    я
    ,
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    ),
    в
    п
    р
    е
    д
    е
    л
    а
    х
    к
    о
    т
    о
    р
    о
    г
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    е
    facility_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    united_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    parent_room_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    к
    в
    а
    р
    т
    и
    р
    ы
    ,
    в
    к
    о
    т
    о
    р
    о
    м
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    а
    к
    о
    м
    н
    а
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ascendant_cad_numbers=None, descendant_cad_numbers=None, parent_cad_number=None, facility_cad_number=None, united_cad_number=None, old_numbers=None, parent_room_cad_number=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.ascendant_cad_numbers = ascendant_cad_numbers
        self.ascendant_cad_numbers_nsprefix_ = None
        self.descendant_cad_numbers = descendant_cad_numbers
        self.descendant_cad_numbers_nsprefix_ = None
        self.parent_cad_number = parent_cad_number
        self.parent_cad_number_nsprefix_ = None
        self.facility_cad_number = facility_cad_number
        self.facility_cad_number_nsprefix_ = None
        self.united_cad_number = united_cad_number
        self.united_cad_number_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
        self.parent_room_cad_number = parent_room_cad_number
        self.parent_room_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksRoomAll)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksRoomAll.subclass:
            return CadLinksRoomAll.subclass(*args_, **kwargs_)
        else:
            return CadLinksRoomAll(*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_ascendant_cad_numbers(self):
        return self.ascendant_cad_numbers
    def set_ascendant_cad_numbers(self, ascendant_cad_numbers):
        self.ascendant_cad_numbers = ascendant_cad_numbers
    def get_descendant_cad_numbers(self):
        return self.descendant_cad_numbers
    def set_descendant_cad_numbers(self, descendant_cad_numbers):
        self.descendant_cad_numbers = descendant_cad_numbers
    def get_parent_cad_number(self):
        return self.parent_cad_number
    def set_parent_cad_number(self, parent_cad_number):
        self.parent_cad_number = parent_cad_number
    def get_facility_cad_number(self):
        return self.facility_cad_number
    def set_facility_cad_number(self, facility_cad_number):
        self.facility_cad_number = facility_cad_number
    def get_united_cad_number(self):
        return self.united_cad_number
    def set_united_cad_number(self, united_cad_number):
        self.united_cad_number = united_cad_number
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def get_parent_room_cad_number(self):
        return self.parent_room_cad_number
    def set_parent_room_cad_number(self, parent_room_cad_number):
        self.parent_room_cad_number = parent_room_cad_number
    def has__content(self):
        if (
            self.ascendant_cad_numbers is not None or
            self.descendant_cad_numbers is not None or
            self.parent_cad_number is not None or
            self.facility_cad_number is not None or
            self.united_cad_number is not None or
            self.old_numbers is not None or
            self.parent_room_cad_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksRoomAll', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksRoomAll')
        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_ == 'CadLinksRoomAll':
            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_='CadLinksRoomAll')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksRoomAll', 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_='CadLinksRoomAll'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksRoomAll', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ascendant_cad_numbers is not None:
            namespaceprefix_ = self.ascendant_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.ascendant_cad_numbers_nsprefix_) else ''
            self.ascendant_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ascendant_cad_numbers', pretty_print=pretty_print)
        if self.descendant_cad_numbers is not None:
            namespaceprefix_ = self.descendant_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.descendant_cad_numbers_nsprefix_) else ''
            self.descendant_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='descendant_cad_numbers', pretty_print=pretty_print)
        if self.parent_cad_number is not None:
            namespaceprefix_ = self.parent_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.parent_cad_number_nsprefix_) else ''
            self.parent_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parent_cad_number', pretty_print=pretty_print)
        if self.facility_cad_number is not None:
            namespaceprefix_ = self.facility_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.facility_cad_number_nsprefix_) else ''
            self.facility_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='facility_cad_number', pretty_print=pretty_print)
        if self.united_cad_number is not None:
            namespaceprefix_ = self.united_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.united_cad_number_nsprefix_) else ''
            self.united_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='united_cad_number', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', pretty_print=pretty_print)
        if self.parent_room_cad_number is not None:
            namespaceprefix_ = self.parent_room_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.parent_room_cad_number_nsprefix_) else ''
            self.parent_room_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parent_room_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ascendant_cad_numbers':
            obj_ = AscendantCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ascendant_cad_numbers = obj_
            obj_.original_tagname_ = 'ascendant_cad_numbers'
        elif nodeName_ == 'descendant_cad_numbers':
            obj_ = DescendantCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.descendant_cad_numbers = obj_
            obj_.original_tagname_ = 'descendant_cad_numbers'
        elif nodeName_ == 'parent_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.parent_cad_number = obj_
            obj_.original_tagname_ = 'parent_cad_number'
        elif nodeName_ == 'facility_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.facility_cad_number = obj_
            obj_.original_tagname_ = 'facility_cad_number'
        elif nodeName_ == 'united_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.united_cad_number = obj_
            obj_.original_tagname_ = 'united_cad_number'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
        elif nodeName_ == 'parent_room_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.parent_room_cad_number = obj_
            obj_.original_tagname_ = 'parent_room_cad_number'
# end class CadLinksRoomAll


class CadLinksCarParkingSpace(GeneratedsSuper):
    """CadLinksCarParkingSpace -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    ascendant_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    и
    з
    к
    о
    т
    о
    р
    ы
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    д
    а
    н
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    descendant_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    о
    б
    р
    а
    з
    о
    в
    а
    н
    н
    ы
    х
    и
    з
    д
    а
    н
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    parent_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    д
    а
    н
    и
    я
    ,
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    ),
    в
    п
    р
    е
    д
    е
    л
    а
    х
    к
    о
    т
    о
    р
    о
    г
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    facility_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    united_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ascendant_cad_numbers=None, descendant_cad_numbers=None, parent_cad_number=None, facility_cad_number=None, united_cad_number=None, old_numbers=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.ascendant_cad_numbers = ascendant_cad_numbers
        self.ascendant_cad_numbers_nsprefix_ = None
        self.descendant_cad_numbers = descendant_cad_numbers
        self.descendant_cad_numbers_nsprefix_ = None
        self.parent_cad_number = parent_cad_number
        self.parent_cad_number_nsprefix_ = None
        self.facility_cad_number = facility_cad_number
        self.facility_cad_number_nsprefix_ = None
        self.united_cad_number = united_cad_number
        self.united_cad_number_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksCarParkingSpace)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksCarParkingSpace.subclass:
            return CadLinksCarParkingSpace.subclass(*args_, **kwargs_)
        else:
            return CadLinksCarParkingSpace(*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_ascendant_cad_numbers(self):
        return self.ascendant_cad_numbers
    def set_ascendant_cad_numbers(self, ascendant_cad_numbers):
        self.ascendant_cad_numbers = ascendant_cad_numbers
    def get_descendant_cad_numbers(self):
        return self.descendant_cad_numbers
    def set_descendant_cad_numbers(self, descendant_cad_numbers):
        self.descendant_cad_numbers = descendant_cad_numbers
    def get_parent_cad_number(self):
        return self.parent_cad_number
    def set_parent_cad_number(self, parent_cad_number):
        self.parent_cad_number = parent_cad_number
    def get_facility_cad_number(self):
        return self.facility_cad_number
    def set_facility_cad_number(self, facility_cad_number):
        self.facility_cad_number = facility_cad_number
    def get_united_cad_number(self):
        return self.united_cad_number
    def set_united_cad_number(self, united_cad_number):
        self.united_cad_number = united_cad_number
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def has__content(self):
        if (
            self.ascendant_cad_numbers is not None or
            self.descendant_cad_numbers is not None or
            self.parent_cad_number is not None or
            self.facility_cad_number is not None or
            self.united_cad_number is not None or
            self.old_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksCarParkingSpace', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksCarParkingSpace')
        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_ == 'CadLinksCarParkingSpace':
            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_='CadLinksCarParkingSpace')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksCarParkingSpace', 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_='CadLinksCarParkingSpace'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksCarParkingSpace', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ascendant_cad_numbers is not None:
            namespaceprefix_ = self.ascendant_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.ascendant_cad_numbers_nsprefix_) else ''
            self.ascendant_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ascendant_cad_numbers', pretty_print=pretty_print)
        if self.descendant_cad_numbers is not None:
            namespaceprefix_ = self.descendant_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.descendant_cad_numbers_nsprefix_) else ''
            self.descendant_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='descendant_cad_numbers', pretty_print=pretty_print)
        if self.parent_cad_number is not None:
            namespaceprefix_ = self.parent_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.parent_cad_number_nsprefix_) else ''
            self.parent_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parent_cad_number', pretty_print=pretty_print)
        if self.facility_cad_number is not None:
            namespaceprefix_ = self.facility_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.facility_cad_number_nsprefix_) else ''
            self.facility_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='facility_cad_number', pretty_print=pretty_print)
        if self.united_cad_number is not None:
            namespaceprefix_ = self.united_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.united_cad_number_nsprefix_) else ''
            self.united_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='united_cad_number', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ascendant_cad_numbers':
            obj_ = AscendantCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ascendant_cad_numbers = obj_
            obj_.original_tagname_ = 'ascendant_cad_numbers'
        elif nodeName_ == 'descendant_cad_numbers':
            obj_ = DescendantCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.descendant_cad_numbers = obj_
            obj_.original_tagname_ = 'descendant_cad_numbers'
        elif nodeName_ == 'parent_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.parent_cad_number = obj_
            obj_.original_tagname_ = 'parent_cad_number'
        elif nodeName_ == 'facility_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.facility_cad_number = obj_
            obj_.original_tagname_ = 'facility_cad_number'
        elif nodeName_ == 'united_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.united_cad_number = obj_
            obj_.original_tagname_ = 'united_cad_number'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
# end class CadLinksCarParkingSpace


class CadLinksCarParkingSpaceBase(GeneratedsSuper):
    """CadLinksCarParkingSpaceBase -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    parent_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    д
    а
    н
    и
    я
    ,
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    ),
    в
    п
    р
    е
    д
    е
    л
    а
    х
    к
    о
    т
    о
    р
    о
    г
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, parent_cad_number=None, old_numbers=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.parent_cad_number = parent_cad_number
        self.parent_cad_number_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksCarParkingSpaceBase)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksCarParkingSpaceBase.subclass:
            return CadLinksCarParkingSpaceBase.subclass(*args_, **kwargs_)
        else:
            return CadLinksCarParkingSpaceBase(*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_parent_cad_number(self):
        return self.parent_cad_number
    def set_parent_cad_number(self, parent_cad_number):
        self.parent_cad_number = parent_cad_number
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def has__content(self):
        if (
            self.parent_cad_number is not None or
            self.old_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksCarParkingSpaceBase', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksCarParkingSpaceBase')
        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_ == 'CadLinksCarParkingSpaceBase':
            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_='CadLinksCarParkingSpaceBase')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksCarParkingSpaceBase', 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_='CadLinksCarParkingSpaceBase'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksCarParkingSpaceBase', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.parent_cad_number is not None:
            namespaceprefix_ = self.parent_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.parent_cad_number_nsprefix_) else ''
            self.parent_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parent_cad_number', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'parent_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.parent_cad_number = obj_
            obj_.original_tagname_ = 'parent_cad_number'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
# end class CadLinksCarParkingSpaceBase


class CadLinksComplex(GeneratedsSuper):
    """CadLinksComplex -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    included_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    в
    х
    о
    д
    я
    щ
    и
    х
    в
    с
    о
    с
    т
    а
    в
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, included_cad_numbers=None, old_numbers=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.included_cad_numbers = included_cad_numbers
        self.included_cad_numbers_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksComplex)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksComplex.subclass:
            return CadLinksComplex.subclass(*args_, **kwargs_)
        else:
            return CadLinksComplex(*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_included_cad_numbers(self):
        return self.included_cad_numbers
    def set_included_cad_numbers(self, included_cad_numbers):
        self.included_cad_numbers = included_cad_numbers
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def has__content(self):
        if (
            self.included_cad_numbers is not None or
            self.old_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksComplex', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksComplex')
        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_ == 'CadLinksComplex':
            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_='CadLinksComplex')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksComplex', 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_='CadLinksComplex'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksComplex', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.included_cad_numbers is not None:
            namespaceprefix_ = self.included_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.included_cad_numbers_nsprefix_) else ''
            self.included_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='included_cad_numbers', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'included_cad_numbers':
            obj_ = IncludedCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.included_cad_numbers = obj_
            obj_.original_tagname_ = 'included_cad_numbers'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
# end class CadLinksComplex


class CadLinksUnderConstruction(GeneratedsSuper):
    """CadLinksUnderConstruction -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    ascendant_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    и
    з
    к
    о
    т
    о
    р
    ы
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    д
    а
    н
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    descendant_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    о
    б
    р
    а
    з
    о
    в
    а
    н
    н
    ы
    х
    и
    з
    д
    а
    н
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    land_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    и
    н
    ы
    х
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ),
    в
    п
    р
    е
    д
    е
    л
    а
    х
    к
    о
    т
    о
    р
    ы
    х
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    facility_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ascendant_cad_numbers=None, descendant_cad_numbers=None, land_cad_numbers=None, facility_cad_number=None, old_numbers=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.ascendant_cad_numbers = ascendant_cad_numbers
        self.ascendant_cad_numbers_nsprefix_ = None
        self.descendant_cad_numbers = descendant_cad_numbers
        self.descendant_cad_numbers_nsprefix_ = None
        self.land_cad_numbers = land_cad_numbers
        self.land_cad_numbers_nsprefix_ = None
        self.facility_cad_number = facility_cad_number
        self.facility_cad_number_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksUnderConstruction)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksUnderConstruction.subclass:
            return CadLinksUnderConstruction.subclass(*args_, **kwargs_)
        else:
            return CadLinksUnderConstruction(*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_ascendant_cad_numbers(self):
        return self.ascendant_cad_numbers
    def set_ascendant_cad_numbers(self, ascendant_cad_numbers):
        self.ascendant_cad_numbers = ascendant_cad_numbers
    def get_descendant_cad_numbers(self):
        return self.descendant_cad_numbers
    def set_descendant_cad_numbers(self, descendant_cad_numbers):
        self.descendant_cad_numbers = descendant_cad_numbers
    def get_land_cad_numbers(self):
        return self.land_cad_numbers
    def set_land_cad_numbers(self, land_cad_numbers):
        self.land_cad_numbers = land_cad_numbers
    def get_facility_cad_number(self):
        return self.facility_cad_number
    def set_facility_cad_number(self, facility_cad_number):
        self.facility_cad_number = facility_cad_number
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def has__content(self):
        if (
            self.ascendant_cad_numbers is not None or
            self.descendant_cad_numbers is not None or
            self.land_cad_numbers is not None or
            self.facility_cad_number is not None or
            self.old_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksUnderConstruction', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksUnderConstruction')
        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_ == 'CadLinksUnderConstruction':
            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_='CadLinksUnderConstruction')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksUnderConstruction', 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_='CadLinksUnderConstruction'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksUnderConstruction', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ascendant_cad_numbers is not None:
            namespaceprefix_ = self.ascendant_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.ascendant_cad_numbers_nsprefix_) else ''
            self.ascendant_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ascendant_cad_numbers', pretty_print=pretty_print)
        if self.descendant_cad_numbers is not None:
            namespaceprefix_ = self.descendant_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.descendant_cad_numbers_nsprefix_) else ''
            self.descendant_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='descendant_cad_numbers', pretty_print=pretty_print)
        if self.land_cad_numbers is not None:
            namespaceprefix_ = self.land_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.land_cad_numbers_nsprefix_) else ''
            self.land_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_cad_numbers', pretty_print=pretty_print)
        if self.facility_cad_number is not None:
            namespaceprefix_ = self.facility_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.facility_cad_number_nsprefix_) else ''
            self.facility_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='facility_cad_number', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ascendant_cad_numbers':
            obj_ = AscendantCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ascendant_cad_numbers = obj_
            obj_.original_tagname_ = 'ascendant_cad_numbers'
        elif nodeName_ == 'descendant_cad_numbers':
            obj_ = DescendantCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.descendant_cad_numbers = obj_
            obj_.original_tagname_ = 'descendant_cad_numbers'
        elif nodeName_ == 'land_cad_numbers':
            obj_ = LandCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_cad_numbers = obj_
            obj_.original_tagname_ = 'land_cad_numbers'
        elif nodeName_ == 'facility_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.facility_cad_number = obj_
            obj_.original_tagname_ = 'facility_cad_number'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
# end class CadLinksUnderConstruction


class CadLinksRealEstateAbout(GeneratedsSuper):
    """CadLinksRealEstateAbout -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    land_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    ,
    е
    с
    л
    и
    в
    х
    о
    д
    я
    щ
    и
    е
    в
    с
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    о
    б
    ъ
    е
    к
    т
    ы
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    ы
    н
    а
    о
    д
    н
    о
    м
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    included_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    в
    х
    о
    д
    я
    щ
    и
    х
    в
    с
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    facility_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_cad_number=None, included_cad_numbers=None, facility_cad_number=None, old_numbers=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.land_cad_number = land_cad_number
        self.land_cad_number_nsprefix_ = None
        self.included_cad_numbers = included_cad_numbers
        self.included_cad_numbers_nsprefix_ = None
        self.facility_cad_number = facility_cad_number
        self.facility_cad_number_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksRealEstateAbout)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksRealEstateAbout.subclass:
            return CadLinksRealEstateAbout.subclass(*args_, **kwargs_)
        else:
            return CadLinksRealEstateAbout(*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_land_cad_number(self):
        return self.land_cad_number
    def set_land_cad_number(self, land_cad_number):
        self.land_cad_number = land_cad_number
    def get_included_cad_numbers(self):
        return self.included_cad_numbers
    def set_included_cad_numbers(self, included_cad_numbers):
        self.included_cad_numbers = included_cad_numbers
    def get_facility_cad_number(self):
        return self.facility_cad_number
    def set_facility_cad_number(self, facility_cad_number):
        self.facility_cad_number = facility_cad_number
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def has__content(self):
        if (
            self.land_cad_number is not None or
            self.included_cad_numbers is not None or
            self.facility_cad_number is not None or
            self.old_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksRealEstateAbout', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksRealEstateAbout')
        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_ == 'CadLinksRealEstateAbout':
            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_='CadLinksRealEstateAbout')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksRealEstateAbout', 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_='CadLinksRealEstateAbout'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksRealEstateAbout', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.land_cad_number is not None:
            namespaceprefix_ = self.land_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.land_cad_number_nsprefix_) else ''
            self.land_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_cad_number', pretty_print=pretty_print)
        if self.included_cad_numbers is not None:
            namespaceprefix_ = self.included_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.included_cad_numbers_nsprefix_) else ''
            self.included_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='included_cad_numbers', pretty_print=pretty_print)
        if self.facility_cad_number is not None:
            namespaceprefix_ = self.facility_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.facility_cad_number_nsprefix_) else ''
            self.facility_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='facility_cad_number', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_cad_number = obj_
            obj_.original_tagname_ = 'land_cad_number'
        elif nodeName_ == 'included_cad_numbers':
            obj_ = IncludedCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.included_cad_numbers = obj_
            obj_.original_tagname_ = 'included_cad_numbers'
        elif nodeName_ == 'facility_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.facility_cad_number = obj_
            obj_.original_tagname_ = 'facility_cad_number'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
# end class CadLinksRealEstateAbout


class CadLinksRealEstateBase(GeneratedsSuper):
    """CadLinksRealEstateBase -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    land_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    ,
    е
    с
    л
    и
    в
    х
    о
    д
    я
    щ
    и
    е
    в
    с
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    о
    б
    ъ
    е
    к
    т
    ы
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    ы
    н
    а
    о
    д
    н
    о
    м
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    included_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    в
    х
    о
    д
    я
    щ
    и
    х
    в
    с
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_cad_number=None, included_cad_numbers=None, old_numbers=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.land_cad_number = land_cad_number
        self.land_cad_number_nsprefix_ = None
        self.included_cad_numbers = included_cad_numbers
        self.included_cad_numbers_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksRealEstateBase)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksRealEstateBase.subclass:
            return CadLinksRealEstateBase.subclass(*args_, **kwargs_)
        else:
            return CadLinksRealEstateBase(*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_land_cad_number(self):
        return self.land_cad_number
    def set_land_cad_number(self, land_cad_number):
        self.land_cad_number = land_cad_number
    def get_included_cad_numbers(self):
        return self.included_cad_numbers
    def set_included_cad_numbers(self, included_cad_numbers):
        self.included_cad_numbers = included_cad_numbers
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def has__content(self):
        if (
            self.land_cad_number is not None or
            self.included_cad_numbers is not None or
            self.old_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksRealEstateBase', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksRealEstateBase')
        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_ == 'CadLinksRealEstateBase':
            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_='CadLinksRealEstateBase')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksRealEstateBase', 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_='CadLinksRealEstateBase'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksRealEstateBase', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.land_cad_number is not None:
            namespaceprefix_ = self.land_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.land_cad_number_nsprefix_) else ''
            self.land_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_cad_number', pretty_print=pretty_print)
        if self.included_cad_numbers is not None:
            namespaceprefix_ = self.included_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.included_cad_numbers_nsprefix_) else ''
            self.included_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='included_cad_numbers', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_cad_number = obj_
            obj_.original_tagname_ = 'land_cad_number'
        elif nodeName_ == 'included_cad_numbers':
            obj_ = IncludedCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.included_cad_numbers = obj_
            obj_.original_tagname_ = 'included_cad_numbers'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
# end class CadLinksRealEstateBase


class CadLinksLandOld(GeneratedsSuper):
    """CadLinksLandOld -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    land_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    и
    н
    ы
    х
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ),
    в
    п
    р
    е
    д
    е
    л
    а
    х
    к
    о
    т
    о
    р
    ы
    х
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_cad_numbers=None, old_numbers=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.land_cad_numbers = land_cad_numbers
        self.land_cad_numbers_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksLandOld)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksLandOld.subclass:
            return CadLinksLandOld.subclass(*args_, **kwargs_)
        else:
            return CadLinksLandOld(*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_land_cad_numbers(self):
        return self.land_cad_numbers
    def set_land_cad_numbers(self, land_cad_numbers):
        self.land_cad_numbers = land_cad_numbers
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def has__content(self):
        if (
            self.land_cad_numbers is not None or
            self.old_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksLandOld', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksLandOld')
        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_ == 'CadLinksLandOld':
            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_='CadLinksLandOld')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksLandOld', 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_='CadLinksLandOld'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksLandOld', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.land_cad_numbers is not None:
            namespaceprefix_ = self.land_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.land_cad_numbers_nsprefix_) else ''
            self.land_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_cad_numbers', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_cad_numbers':
            obj_ = LandCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_cad_numbers = obj_
            obj_.original_tagname_ = 'land_cad_numbers'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
# end class CadLinksLandOld


class CadLinksLandIncludedOld(GeneratedsSuper):
    """CadLinksLandIncludedOld -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    included_objects -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    п
    р
    е
    д
    е
    л
    а
    х
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, included_objects=None, old_numbers=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.included_objects = included_objects
        self.included_objects_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksLandIncludedOld)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksLandIncludedOld.subclass:
            return CadLinksLandIncludedOld.subclass(*args_, **kwargs_)
        else:
            return CadLinksLandIncludedOld(*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_included_objects(self):
        return self.included_objects
    def set_included_objects(self, included_objects):
        self.included_objects = included_objects
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def has__content(self):
        if (
            self.included_objects is not None or
            self.old_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksLandIncludedOld', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksLandIncludedOld')
        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_ == 'CadLinksLandIncludedOld':
            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_='CadLinksLandIncludedOld')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksLandIncludedOld', 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_='CadLinksLandIncludedOld'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksLandIncludedOld', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.included_objects is not None:
            namespaceprefix_ = self.included_objects_nsprefix_ + ':' if (UseCapturedNS_ and self.included_objects_nsprefix_) else ''
            self.included_objects.export(outfile, level, namespaceprefix_, namespacedef_='', name_='included_objects', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'included_objects':
            obj_ = IncludedObjects.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.included_objects = obj_
            obj_.original_tagname_ = 'included_objects'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
# end class CadLinksLandIncludedOld


class CadLinksLandAll(GeneratedsSuper):
    """CadLinksLandAll -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    (
    с
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    )
    ascendant_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ,
    и
    з
    к
    о
    т
    о
    р
    ы
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    д
    а
    н
    н
    ы
    й
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    descendant_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ,
    о
    б
    р
    а
    з
    о
    в
    а
    н
    н
    ы
    х
    и
    з
    д
    а
    н
    н
    о
    г
    о
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    included_objects -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    п
    р
    е
    д
    е
    л
    а
    х
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    facility_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    old_numbers -- Р
    а
    н
    е
    е
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    е
    н
    о
    м
    е
    р
    а
    common_land -- Е
    д
    и
    н
    о
    е
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ascendant_cad_numbers=None, descendant_cad_numbers=None, included_objects=None, facility_cad_number=None, old_numbers=None, common_land=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.ascendant_cad_numbers = ascendant_cad_numbers
        self.ascendant_cad_numbers_nsprefix_ = None
        self.descendant_cad_numbers = descendant_cad_numbers
        self.descendant_cad_numbers_nsprefix_ = None
        self.included_objects = included_objects
        self.included_objects_nsprefix_ = None
        self.facility_cad_number = facility_cad_number
        self.facility_cad_number_nsprefix_ = None
        self.old_numbers = old_numbers
        self.old_numbers_nsprefix_ = None
        self.common_land = common_land
        self.common_land_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadLinksLandAll)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadLinksLandAll.subclass:
            return CadLinksLandAll.subclass(*args_, **kwargs_)
        else:
            return CadLinksLandAll(*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_ascendant_cad_numbers(self):
        return self.ascendant_cad_numbers
    def set_ascendant_cad_numbers(self, ascendant_cad_numbers):
        self.ascendant_cad_numbers = ascendant_cad_numbers
    def get_descendant_cad_numbers(self):
        return self.descendant_cad_numbers
    def set_descendant_cad_numbers(self, descendant_cad_numbers):
        self.descendant_cad_numbers = descendant_cad_numbers
    def get_included_objects(self):
        return self.included_objects
    def set_included_objects(self, included_objects):
        self.included_objects = included_objects
    def get_facility_cad_number(self):
        return self.facility_cad_number
    def set_facility_cad_number(self, facility_cad_number):
        self.facility_cad_number = facility_cad_number
    def get_old_numbers(self):
        return self.old_numbers
    def set_old_numbers(self, old_numbers):
        self.old_numbers = old_numbers
    def get_common_land(self):
        return self.common_land
    def set_common_land(self, common_land):
        self.common_land = common_land
    def has__content(self):
        if (
            self.ascendant_cad_numbers is not None or
            self.descendant_cad_numbers is not None or
            self.included_objects is not None or
            self.facility_cad_number is not None or
            self.old_numbers is not None or
            self.common_land is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksLandAll', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadLinksLandAll')
        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_ == 'CadLinksLandAll':
            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_='CadLinksLandAll')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadLinksLandAll', 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_='CadLinksLandAll'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadLinksLandAll', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ascendant_cad_numbers is not None:
            namespaceprefix_ = self.ascendant_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.ascendant_cad_numbers_nsprefix_) else ''
            self.ascendant_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ascendant_cad_numbers', pretty_print=pretty_print)
        if self.descendant_cad_numbers is not None:
            namespaceprefix_ = self.descendant_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.descendant_cad_numbers_nsprefix_) else ''
            self.descendant_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='descendant_cad_numbers', pretty_print=pretty_print)
        if self.included_objects is not None:
            namespaceprefix_ = self.included_objects_nsprefix_ + ':' if (UseCapturedNS_ and self.included_objects_nsprefix_) else ''
            self.included_objects.export(outfile, level, namespaceprefix_, namespacedef_='', name_='included_objects', pretty_print=pretty_print)
        if self.facility_cad_number is not None:
            namespaceprefix_ = self.facility_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.facility_cad_number_nsprefix_) else ''
            self.facility_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='facility_cad_number', pretty_print=pretty_print)
        if self.old_numbers is not None:
            namespaceprefix_ = self.old_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.old_numbers_nsprefix_) else ''
            self.old_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='old_numbers', pretty_print=pretty_print)
        if self.common_land is not None:
            namespaceprefix_ = self.common_land_nsprefix_ + ':' if (UseCapturedNS_ and self.common_land_nsprefix_) else ''
            self.common_land.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_land', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ascendant_cad_numbers':
            obj_ = AscendantCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ascendant_cad_numbers = obj_
            obj_.original_tagname_ = 'ascendant_cad_numbers'
        elif nodeName_ == 'descendant_cad_numbers':
            obj_ = DescendantCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.descendant_cad_numbers = obj_
            obj_.original_tagname_ = 'descendant_cad_numbers'
        elif nodeName_ == 'included_objects':
            obj_ = IncludedObjects.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.included_objects = obj_
            obj_.original_tagname_ = 'included_objects'
        elif nodeName_ == 'facility_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.facility_cad_number = obj_
            obj_.original_tagname_ = 'facility_cad_number'
        elif nodeName_ == 'old_numbers':
            obj_ = OldNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.old_numbers = obj_
            obj_.original_tagname_ = 'old_numbers'
        elif nodeName_ == 'common_land':
            obj_ = CommonLand.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_land = obj_
            obj_.original_tagname_ = 'common_land'
# end class CadLinksLandAll


class IncludedCadNumbers(GeneratedsSuper):
    """IncludedCadNumbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    included_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, included_cad_number=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 included_cad_number is None:
            self.included_cad_number = []
        else:
            self.included_cad_number = included_cad_number
        self.included_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IncludedCadNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IncludedCadNumbers.subclass:
            return IncludedCadNumbers.subclass(*args_, **kwargs_)
        else:
            return IncludedCadNumbers(*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_included_cad_number(self):
        return self.included_cad_number
    def set_included_cad_number(self, included_cad_number):
        self.included_cad_number = included_cad_number
    def add_included_cad_number(self, value):
        self.included_cad_number.append(value)
    def insert_included_cad_number_at(self, index, value):
        self.included_cad_number.insert(index, value)
    def replace_included_cad_number_at(self, index, value):
        self.included_cad_number[index] = value
    def has__content(self):
        if (
            self.included_cad_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncludedCadNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IncludedCadNumbers')
        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_ == 'IncludedCadNumbers':
            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_='IncludedCadNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IncludedCadNumbers', 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_='IncludedCadNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncludedCadNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for included_cad_number_ in self.included_cad_number:
            namespaceprefix_ = self.included_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.included_cad_number_nsprefix_) else ''
            included_cad_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='included_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'included_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.included_cad_number.append(obj_)
            obj_.original_tagname_ = 'included_cad_number'
# end class IncludedCadNumbers


class IncludedObjects(GeneratedsSuper):
    """IncludedObjects -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    п
    р
    е
    д
    е
    л
    а
    х
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    included_object -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, included_object=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 included_object is None:
            self.included_object = []
        else:
            self.included_object = included_object
        self.included_object_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IncludedObjects)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IncludedObjects.subclass:
            return IncludedObjects.subclass(*args_, **kwargs_)
        else:
            return IncludedObjects(*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_included_object(self):
        return self.included_object
    def set_included_object(self, included_object):
        self.included_object = included_object
    def add_included_object(self, value):
        self.included_object.append(value)
    def insert_included_object_at(self, index, value):
        self.included_object.insert(index, value)
    def replace_included_object_at(self, index, value):
        self.included_object[index] = value
    def has__content(self):
        if (
            self.included_object
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncludedObjects', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IncludedObjects')
        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_ == 'IncludedObjects':
            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_='IncludedObjects')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IncludedObjects', 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_='IncludedObjects'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncludedObjects', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for included_object_ in self.included_object:
            namespaceprefix_ = self.included_object_nsprefix_ + ':' if (UseCapturedNS_ and self.included_object_nsprefix_) else ''
            included_object_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='included_object', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'included_object':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.included_object.append(obj_)
            obj_.original_tagname_ = 'included_object'
# end class IncludedObjects


class LandCadNumbers(GeneratedsSuper):
    """LandCadNumbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    и
    н
    ы
    х
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ),
    в
    п
    р
    е
    д
    е
    л
    а
    х
    к
    о
    т
    о
    р
    ы
    х
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    land_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    ),
    в
    п
    р
    е
    д
    е
    л
    а
    х
    к
    о
    т
    о
    р
    о
    г
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_cad_number=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 land_cad_number is None:
            self.land_cad_number = []
        else:
            self.land_cad_number = land_cad_number
        self.land_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LandCadNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LandCadNumbers.subclass:
            return LandCadNumbers.subclass(*args_, **kwargs_)
        else:
            return LandCadNumbers(*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_land_cad_number(self):
        return self.land_cad_number
    def set_land_cad_number(self, land_cad_number):
        self.land_cad_number = land_cad_number
    def add_land_cad_number(self, value):
        self.land_cad_number.append(value)
    def insert_land_cad_number_at(self, index, value):
        self.land_cad_number.insert(index, value)
    def replace_land_cad_number_at(self, index, value):
        self.land_cad_number[index] = value
    def has__content(self):
        if (
            self.land_cad_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandCadNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LandCadNumbers')
        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_ == 'LandCadNumbers':
            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_='LandCadNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LandCadNumbers', 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_='LandCadNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandCadNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for land_cad_number_ in self.land_cad_number:
            namespaceprefix_ = self.land_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.land_cad_number_nsprefix_) else ''
            land_cad_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_cad_number.append(obj_)
            obj_.original_tagname_ = 'land_cad_number'
# end class LandCadNumbers


class RoomCadNumbers(GeneratedsSuper):
    """RoomCadNumbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    з
    д
    а
    н
    и
    и
    ,
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    и
    )
    room_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, room_cad_number=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 room_cad_number is None:
            self.room_cad_number = []
        else:
            self.room_cad_number = room_cad_number
        self.room_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomCadNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomCadNumbers.subclass:
            return RoomCadNumbers.subclass(*args_, **kwargs_)
        else:
            return RoomCadNumbers(*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_room_cad_number(self):
        return self.room_cad_number
    def set_room_cad_number(self, room_cad_number):
        self.room_cad_number = room_cad_number
    def add_room_cad_number(self, value):
        self.room_cad_number.append(value)
    def insert_room_cad_number_at(self, index, value):
        self.room_cad_number.insert(index, value)
    def replace_room_cad_number_at(self, index, value):
        self.room_cad_number[index] = value
    def has__content(self):
        if (
            self.room_cad_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomCadNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomCadNumbers')
        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_ == 'RoomCadNumbers':
            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_='RoomCadNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomCadNumbers', 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_='RoomCadNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomCadNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for room_cad_number_ in self.room_cad_number:
            namespaceprefix_ = self.room_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.room_cad_number_nsprefix_) else ''
            room_cad_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'room_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_cad_number.append(obj_)
            obj_.original_tagname_ = 'room_cad_number'
# end class RoomCadNumbers


class CarParkingPlaceCadNumbers(GeneratedsSuper):
    """CarParkingPlaceCadNumbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    з
    д
    а
    н
    и
    и
    ,
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    и
    )
    car_parking_place_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, car_parking_place_cad_number=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 car_parking_place_cad_number is None:
            self.car_parking_place_cad_number = []
        else:
            self.car_parking_place_cad_number = car_parking_place_cad_number
        self.car_parking_place_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CarParkingPlaceCadNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CarParkingPlaceCadNumbers.subclass:
            return CarParkingPlaceCadNumbers.subclass(*args_, **kwargs_)
        else:
            return CarParkingPlaceCadNumbers(*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_car_parking_place_cad_number(self):
        return self.car_parking_place_cad_number
    def set_car_parking_place_cad_number(self, car_parking_place_cad_number):
        self.car_parking_place_cad_number = car_parking_place_cad_number
    def add_car_parking_place_cad_number(self, value):
        self.car_parking_place_cad_number.append(value)
    def insert_car_parking_place_cad_number_at(self, index, value):
        self.car_parking_place_cad_number.insert(index, value)
    def replace_car_parking_place_cad_number_at(self, index, value):
        self.car_parking_place_cad_number[index] = value
    def has__content(self):
        if (
            self.car_parking_place_cad_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CarParkingPlaceCadNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CarParkingPlaceCadNumbers')
        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_ == 'CarParkingPlaceCadNumbers':
            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_='CarParkingPlaceCadNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CarParkingPlaceCadNumbers', 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_='CarParkingPlaceCadNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CarParkingPlaceCadNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for car_parking_place_cad_number_ in self.car_parking_place_cad_number:
            namespaceprefix_ = self.car_parking_place_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.car_parking_place_cad_number_nsprefix_) else ''
            car_parking_place_cad_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='car_parking_place_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'car_parking_place_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.car_parking_place_cad_number.append(obj_)
            obj_.original_tagname_ = 'car_parking_place_cad_number'
# end class CarParkingPlaceCadNumbers


class AscendantCadNumbers(GeneratedsSuper):
    """AscendantCadNumbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    и
    з
    к
    о
    т
    о
    р
    ы
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    д
    а
    н
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ascendant_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ascendant_cad_number=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 ascendant_cad_number is None:
            self.ascendant_cad_number = []
        else:
            self.ascendant_cad_number = ascendant_cad_number
        self.ascendant_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AscendantCadNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AscendantCadNumbers.subclass:
            return AscendantCadNumbers.subclass(*args_, **kwargs_)
        else:
            return AscendantCadNumbers(*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_ascendant_cad_number(self):
        return self.ascendant_cad_number
    def set_ascendant_cad_number(self, ascendant_cad_number):
        self.ascendant_cad_number = ascendant_cad_number
    def add_ascendant_cad_number(self, value):
        self.ascendant_cad_number.append(value)
    def insert_ascendant_cad_number_at(self, index, value):
        self.ascendant_cad_number.insert(index, value)
    def replace_ascendant_cad_number_at(self, index, value):
        self.ascendant_cad_number[index] = value
    def has__content(self):
        if (
            self.ascendant_cad_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AscendantCadNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AscendantCadNumbers')
        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_ == 'AscendantCadNumbers':
            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_='AscendantCadNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AscendantCadNumbers', 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_='AscendantCadNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AscendantCadNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ascendant_cad_number_ in self.ascendant_cad_number:
            namespaceprefix_ = self.ascendant_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.ascendant_cad_number_nsprefix_) else ''
            ascendant_cad_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ascendant_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ascendant_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ascendant_cad_number.append(obj_)
            obj_.original_tagname_ = 'ascendant_cad_number'
# end class AscendantCadNumbers


class DescendantCadNumbers(GeneratedsSuper):
    """DescendantCadNumbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    о
    б
    р
    а
    з
    о
    в
    а
    н
    н
    ы
    х
    и
    з
    д
    а
    н
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    descendant_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, descendant_cad_number=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 descendant_cad_number is None:
            self.descendant_cad_number = []
        else:
            self.descendant_cad_number = descendant_cad_number
        self.descendant_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DescendantCadNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DescendantCadNumbers.subclass:
            return DescendantCadNumbers.subclass(*args_, **kwargs_)
        else:
            return DescendantCadNumbers(*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_descendant_cad_number(self):
        return self.descendant_cad_number
    def set_descendant_cad_number(self, descendant_cad_number):
        self.descendant_cad_number = descendant_cad_number
    def add_descendant_cad_number(self, value):
        self.descendant_cad_number.append(value)
    def insert_descendant_cad_number_at(self, index, value):
        self.descendant_cad_number.insert(index, value)
    def replace_descendant_cad_number_at(self, index, value):
        self.descendant_cad_number[index] = value
    def has__content(self):
        if (
            self.descendant_cad_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DescendantCadNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DescendantCadNumbers')
        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_ == 'DescendantCadNumbers':
            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_='DescendantCadNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DescendantCadNumbers', 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_='DescendantCadNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DescendantCadNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for descendant_cad_number_ in self.descendant_cad_number:
            namespaceprefix_ = self.descendant_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.descendant_cad_number_nsprefix_) else ''
            descendant_cad_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='descendant_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'descendant_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.descendant_cad_number.append(obj_)
            obj_.original_tagname_ = 'descendant_cad_number'
# end class DescendantCadNumbers


class UnitedCadNumbers(GeneratedsSuper):
    """UnitedCadNumbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    д
    а
    н
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    united_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    ,
    в
    с
    о
    с
    т
    а
    в
    к
    о
    т
    о
    р
    о
    г
    о
    в
    х
    о
    д
    и
    т
    д
    а
    н
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, united_cad_number=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.united_cad_number = united_cad_number
        self.united_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, UnitedCadNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if UnitedCadNumbers.subclass:
            return UnitedCadNumbers.subclass(*args_, **kwargs_)
        else:
            return UnitedCadNumbers(*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_united_cad_number(self):
        return self.united_cad_number
    def set_united_cad_number(self, united_cad_number):
        self.united_cad_number = united_cad_number
    def has__content(self):
        if (
            self.united_cad_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnitedCadNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnitedCadNumbers')
        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_ == 'UnitedCadNumbers':
            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_='UnitedCadNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnitedCadNumbers', 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_='UnitedCadNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnitedCadNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.united_cad_number is not None:
            namespaceprefix_ = self.united_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.united_cad_number_nsprefix_) else ''
            self.united_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='united_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'united_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.united_cad_number = obj_
            obj_.original_tagname_ = 'united_cad_number'
# end class UnitedCadNumbers


class CommonLandCadNumbers(GeneratedsSuper):
    """CommonLandCadNumbers -- Е
    д
    и
    н
    о
    е
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    common_land -- Е
    д
    и
    н
    о
    е
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, common_land=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.common_land = common_land
        self.common_land_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CommonLandCadNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CommonLandCadNumbers.subclass:
            return CommonLandCadNumbers.subclass(*args_, **kwargs_)
        else:
            return CommonLandCadNumbers(*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_common_land(self):
        return self.common_land
    def set_common_land(self, common_land):
        self.common_land = common_land
    def has__content(self):
        if (
            self.common_land is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonLandCadNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CommonLandCadNumbers')
        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_ == 'CommonLandCadNumbers':
            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_='CommonLandCadNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CommonLandCadNumbers', 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_='CommonLandCadNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonLandCadNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.common_land is not None:
            namespaceprefix_ = self.common_land_nsprefix_ + ':' if (UseCapturedNS_ and self.common_land_nsprefix_) else ''
            self.common_land.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_land', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'common_land':
            obj_ = CommonLandCadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_land = obj_
            obj_.original_tagname_ = 'common_land'
# end class CommonLandCadNumbers


class CommonLandCadNumber(GeneratedsSuper):
    """CommonLandCadNumber -- Е
    д
    и
    н
    о
    е
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    common_land_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    е
    д
    и
    н
    о
    г
    о
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    (
    е
    с
    л
    и
    в
    и
    д
    З
    У
    = 03-
    О
    б
    о
    с
    о
    б
    л
    е
    н
    н
    ы
    й
    и
    л
    и
    04-
    У
    с
    л
    о
    в
    н
    ы
    й
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, common_land_cad_number=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.common_land_cad_number = common_land_cad_number
        self.common_land_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CommonLandCadNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CommonLandCadNumber.subclass:
            return CommonLandCadNumber.subclass(*args_, **kwargs_)
        else:
            return CommonLandCadNumber(*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_common_land_cad_number(self):
        return self.common_land_cad_number
    def set_common_land_cad_number(self, common_land_cad_number):
        self.common_land_cad_number = common_land_cad_number
    def has__content(self):
        if (
            self.common_land_cad_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonLandCadNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CommonLandCadNumber')
        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_ == 'CommonLandCadNumber':
            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_='CommonLandCadNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CommonLandCadNumber', 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_='CommonLandCadNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonLandCadNumber', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.common_land_cad_number is not None:
            namespaceprefix_ = self.common_land_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.common_land_cad_number_nsprefix_) else ''
            self.common_land_cad_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_land_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'common_land_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_land_cad_number = obj_
            obj_.original_tagname_ = 'common_land_cad_number'
# end class CommonLandCadNumber


class CommonLand(GeneratedsSuper):
    """CommonLand -- Е
    д
    и
    н
    о
    е
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    (
    К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ,
    в
    х
    о
    д
    я
    щ
    и
    х
    в
    с
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    )
    common_land_parts -- С
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, common_land_parts=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.common_land_parts = common_land_parts
        self.common_land_parts_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CommonLand)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CommonLand.subclass:
            return CommonLand.subclass(*args_, **kwargs_)
        else:
            return CommonLand(*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_common_land_parts(self):
        return self.common_land_parts
    def set_common_land_parts(self, common_land_parts):
        self.common_land_parts = common_land_parts
    def has__content(self):
        if (
            self.common_land_parts is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonLand', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CommonLand')
        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_ == 'CommonLand':
            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_='CommonLand')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CommonLand', 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_='CommonLand'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CommonLand', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.common_land_parts is not None:
            namespaceprefix_ = self.common_land_parts_nsprefix_ + ':' if (UseCapturedNS_ and self.common_land_parts_nsprefix_) else ''
            self.common_land_parts.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_land_parts', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'common_land_parts':
            obj_ = common_land_partsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_land_parts = obj_
            obj_.original_tagname_ = 'common_land_parts'
# end class CommonLand


class ApartmentBuildingUse(GeneratedsSuper):
    """ApartmentBuildingUse -- С
    в
    е
    д
    е
    н
    и
    я
    о
    с
    о
    з
    д
    а
    н
    и
    и
    (
    э
    к
    с
    п
    л
    у
    а
    т
    а
    ц
    и
    и
    )
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    н
    а
    е
    м
    н
    о
    г
    о
    д
    о
    м
    а
    (
    в
    т
    .
    ч
    .
    в
    и
    д
    и
    с
    п
    о
    л
    ь
    з
    в
    а
    н
    и
    я
    и
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    З
    У
    )
    purpose_hired_home -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    у
    ч
    а
    с
    т
    к
    а
    п
    о
    д
    н
    а
    е
    м
    н
    ы
    й
    д
    о
    м
    use_apart_build -- В
    и
    д
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    н
    а
    е
    м
    н
    о
    г
    о
    д
    о
    м
    а
    basis_hired_house -- О
    с
    н
    о
    в
    а
    н
    и
    е
    с
    о
    з
    д
    а
    н
    и
    я
    н
    а
    е
    м
    н
    о
    г
    о
    д
    о
    м
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, purpose_hired_home=None, use_apart_build=None, basis_hired_house=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.purpose_hired_home = purpose_hired_home
        self.purpose_hired_home_nsprefix_ = None
        self.use_apart_build = use_apart_build
        self.use_apart_build_nsprefix_ = None
        self.basis_hired_house = basis_hired_house
        self.basis_hired_house_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ApartmentBuildingUse)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ApartmentBuildingUse.subclass:
            return ApartmentBuildingUse.subclass(*args_, **kwargs_)
        else:
            return ApartmentBuildingUse(*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_purpose_hired_home(self):
        return self.purpose_hired_home
    def set_purpose_hired_home(self, purpose_hired_home):
        self.purpose_hired_home = purpose_hired_home
    def get_use_apart_build(self):
        return self.use_apart_build
    def set_use_apart_build(self, use_apart_build):
        self.use_apart_build = use_apart_build
    def get_basis_hired_house(self):
        return self.basis_hired_house
    def set_basis_hired_house(self, basis_hired_house):
        self.basis_hired_house = basis_hired_house
    def has__content(self):
        if (
            self.purpose_hired_home is not None or
            self.use_apart_build is not None or
            self.basis_hired_house is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ApartmentBuildingUse', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ApartmentBuildingUse')
        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_ == 'ApartmentBuildingUse':
            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_='ApartmentBuildingUse')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ApartmentBuildingUse', 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_='ApartmentBuildingUse'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ApartmentBuildingUse', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.purpose_hired_home is not None:
            namespaceprefix_ = self.purpose_hired_home_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_hired_home_nsprefix_) else ''
            self.purpose_hired_home.export(outfile, level, namespaceprefix_, namespacedef_='', name_='purpose_hired_home', pretty_print=pretty_print)
        if self.use_apart_build is not None:
            namespaceprefix_ = self.use_apart_build_nsprefix_ + ':' if (UseCapturedNS_ and self.use_apart_build_nsprefix_) else ''
            self.use_apart_build.export(outfile, level, namespaceprefix_, namespacedef_='', name_='use_apart_build', pretty_print=pretty_print)
        if self.basis_hired_house is not None:
            namespaceprefix_ = self.basis_hired_house_nsprefix_ + ':' if (UseCapturedNS_ and self.basis_hired_house_nsprefix_) else ''
            self.basis_hired_house.export(outfile, level, namespaceprefix_, namespacedef_='', name_='basis_hired_house', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'purpose_hired_home':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.purpose_hired_home = obj_
            obj_.original_tagname_ = 'purpose_hired_home'
        elif nodeName_ == 'use_apart_build':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.use_apart_build = obj_
            obj_.original_tagname_ = 'use_apart_build'
        elif nodeName_ == 'basis_hired_house':
            obj_ = BasisHiredHouse.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.basis_hired_house = obj_
            obj_.original_tagname_ = 'basis_hired_house'
# end class ApartmentBuildingUse


class ZonesAndBoundaries(GeneratedsSuper):
    """ZonesAndBoundaries -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    з
    о
    н
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    й
    special_economic_boundary -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    о
    с
    о
    б
    о
    й
    э
    к
    о
    н
    о
    м
    и
    ч
    е
    с
    к
    о
    й
    з
    о
    н
    ы
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    о
    п
    е
    р
    е
    ж
    а
    ю
    щ
    е
    г
    о
    с
    о
    ц
    и
    а
    л
    ь
    н
    о
    -
    э
    к
    о
    н
    о
    м
    и
    ч
    е
    с
    к
    о
    г
    о
    р
    а
    з
    в
    и
    т
    и
    я
    ,
    з
    о
    н
    ы
    т
    е
    р
    р
    и
    т
    о
    р
    и
    а
    л
    ь
    н
    о
    г
    о
    р
    а
    з
    в
    и
    т
    и
    я
    в
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    ,
    и
    г
    о
    р
    н
    о
    й
    з
    о
    н
    ы
    special_use_boundaries -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    п
    о
    л
    н
    о
    с
    т
    ь
    ю
    и
    л
    и
    ч
    а
    с
    т
    и
    ч
    н
    о
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    з
    о
    н
    ы
    с
    о
    с
    о
    б
    ы
    м
    и
    у
    с
    л
    о
    в
    и
    я
    м
    и
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    и
    л
    и
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    к
    у
    л
    ь
    т
    у
    р
    н
    о
    г
    о
    н
    а
    с
    л
    е
    д
    и
    я
    guarded_natural_boundaries -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    о
    с
    о
    б
    о
    о
    х
    р
    а
    н
    я
    е
    м
    о
    й
    п
    р
    и
    р
    о
    д
    н
    о
    й
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    ,
    о
    х
    о
    т
    н
    и
    ч
    ь
    и
    х
    у
    г
    о
    д
    и
    й
    ,
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    ,
    л
    е
    с
    о
    п
    а
    р
    к
    о
    в
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, special_economic_boundary=None, special_use_boundaries=None, guarded_natural_boundaries=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.special_economic_boundary = special_economic_boundary
        self.special_economic_boundary_nsprefix_ = None
        self.special_use_boundaries = special_use_boundaries
        self.special_use_boundaries_nsprefix_ = None
        self.guarded_natural_boundaries = guarded_natural_boundaries
        self.guarded_natural_boundaries_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ZonesAndBoundaries)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ZonesAndBoundaries.subclass:
            return ZonesAndBoundaries.subclass(*args_, **kwargs_)
        else:
            return ZonesAndBoundaries(*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_special_economic_boundary(self):
        return self.special_economic_boundary
    def set_special_economic_boundary(self, special_economic_boundary):
        self.special_economic_boundary = special_economic_boundary
    def get_special_use_boundaries(self):
        return self.special_use_boundaries
    def set_special_use_boundaries(self, special_use_boundaries):
        self.special_use_boundaries = special_use_boundaries
    def get_guarded_natural_boundaries(self):
        return self.guarded_natural_boundaries
    def set_guarded_natural_boundaries(self, guarded_natural_boundaries):
        self.guarded_natural_boundaries = guarded_natural_boundaries
    def has__content(self):
        if (
            self.special_economic_boundary is not None or
            self.special_use_boundaries is not None or
            self.guarded_natural_boundaries is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ZonesAndBoundaries', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ZonesAndBoundaries')
        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_ == 'ZonesAndBoundaries':
            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_='ZonesAndBoundaries')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ZonesAndBoundaries', 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_='ZonesAndBoundaries'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ZonesAndBoundaries', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.special_economic_boundary is not None:
            namespaceprefix_ = self.special_economic_boundary_nsprefix_ + ':' if (UseCapturedNS_ and self.special_economic_boundary_nsprefix_) else ''
            self.special_economic_boundary.export(outfile, level, namespaceprefix_, namespacedef_='', name_='special_economic_boundary', pretty_print=pretty_print)
        if self.special_use_boundaries is not None:
            namespaceprefix_ = self.special_use_boundaries_nsprefix_ + ':' if (UseCapturedNS_ and self.special_use_boundaries_nsprefix_) else ''
            self.special_use_boundaries.export(outfile, level, namespaceprefix_, namespacedef_='', name_='special_use_boundaries', pretty_print=pretty_print)
        if self.guarded_natural_boundaries is not None:
            namespaceprefix_ = self.guarded_natural_boundaries_nsprefix_ + ':' if (UseCapturedNS_ and self.guarded_natural_boundaries_nsprefix_) else ''
            self.guarded_natural_boundaries.export(outfile, level, namespaceprefix_, namespacedef_='', name_='guarded_natural_boundaries', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'special_economic_boundary':
            obj_ = SpecialEconomicBoundary.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.special_economic_boundary = obj_
            obj_.original_tagname_ = 'special_economic_boundary'
        elif nodeName_ == 'special_use_boundaries':
            obj_ = SpecialUseBoundaries.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.special_use_boundaries = obj_
            obj_.original_tagname_ = 'special_use_boundaries'
        elif nodeName_ == 'guarded_natural_boundaries':
            obj_ = GuardedNaturalBoundaries.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.guarded_natural_boundaries = obj_
            obj_.original_tagname_ = 'guarded_natural_boundaries'
# end class ZonesAndBoundaries


class SpecialEconomicBoundary(GeneratedsSuper):
    """SpecialEconomicBoundary -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    о
    с
    о
    б
    о
    й
    э
    к
    о
    н
    о
    м
    и
    ч
    е
    с
    к
    о
    й
    з
    о
    н
    ы
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    о
    п
    е
    р
    е
    ж
    а
    ю
    щ
    е
    г
    о
    с
    о
    ц
    и
    а
    л
    ь
    н
    о
    -
    э
    к
    о
    н
    о
    м
    и
    ч
    е
    с
    к
    о
    г
    о
    р
    а
    з
    в
    и
    т
    и
    я
    ,
    з
    о
    н
    ы
    т
    е
    р
    р
    и
    т
    о
    р
    и
    а
    л
    ь
    н
    о
    г
    о
    р
    а
    з
    в
    и
    т
    и
    я
    в
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    ,
    и
    г
    о
    р
    н
    о
    й
    з
    о
    н
    ы
    special_economic_boundaries -- О
    с
    о
    б
    а
    я
    э
    к
    о
    н
    о
    м
    и
    ч
    е
    с
    к
    а
    я
    з
    о
    н
    а
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    я
    о
    п
    е
    р
    е
    ж
    а
    ю
    щ
    е
    г
    о
    с
    о
    ц
    и
    а
    л
    ь
    н
    о
    -
    э
    к
    о
    н
    о
    м
    и
    ч
    е
    с
    к
    о
    г
    о
    р
    а
    з
    в
    и
    т
    и
    я
    ,
    з
    о
    н
    а
    т
    е
    р
    р
    и
    т
    о
    р
    и
    а
    л
    ь
    н
    о
    г
    о
    р
    а
    з
    в
    и
    т
    и
    я
    ,
    и
    г
    о
    р
    н
    а
    я
    з
    о
    н
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, special_economic_boundaries=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 special_economic_boundaries is None:
            self.special_economic_boundaries = []
        else:
            self.special_economic_boundaries = special_economic_boundaries
        self.special_economic_boundaries_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpecialEconomicBoundary)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpecialEconomicBoundary.subclass:
            return SpecialEconomicBoundary.subclass(*args_, **kwargs_)
        else:
            return SpecialEconomicBoundary(*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_special_economic_boundaries(self):
        return self.special_economic_boundaries
    def set_special_economic_boundaries(self, special_economic_boundaries):
        self.special_economic_boundaries = special_economic_boundaries
    def add_special_economic_boundaries(self, value):
        self.special_economic_boundaries.append(value)
    def insert_special_economic_boundaries_at(self, index, value):
        self.special_economic_boundaries.insert(index, value)
    def replace_special_economic_boundaries_at(self, index, value):
        self.special_economic_boundaries[index] = value
    def has__content(self):
        if (
            self.special_economic_boundaries
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecialEconomicBoundary', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpecialEconomicBoundary')
        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_ == 'SpecialEconomicBoundary':
            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_='SpecialEconomicBoundary')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpecialEconomicBoundary', 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_='SpecialEconomicBoundary'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecialEconomicBoundary', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for special_economic_boundaries_ in self.special_economic_boundaries:
            namespaceprefix_ = self.special_economic_boundaries_nsprefix_ + ':' if (UseCapturedNS_ and self.special_economic_boundaries_nsprefix_) else ''
            special_economic_boundaries_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='special_economic_boundaries', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'special_economic_boundaries':
            obj_ = RegNumbBorder.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.special_economic_boundaries.append(obj_)
            obj_.original_tagname_ = 'special_economic_boundaries'
# end class SpecialEconomicBoundary


class SpecialUseBoundaries(GeneratedsSuper):
    """SpecialUseBoundaries -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    п
    о
    л
    н
    о
    с
    т
    ь
    ю
    и
    л
    и
    ч
    а
    с
    т
    и
    ч
    н
    о
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    з
    о
    н
    ы
    с
    о
    с
    о
    б
    ы
    м
    и
    у
    с
    л
    о
    в
    и
    я
    м
    и
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    и
    л
    и
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    к
    у
    л
    ь
    т
    у
    р
    н
    о
    г
    о
    н
    а
    с
    л
    е
    д
    и
    я
    special_use_boundary -- З
    о
    н
    а
    с
    о
    с
    о
    б
    ы
    м
    и
    у
    с
    л
    о
    в
    и
    я
    м
    и
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    к
    у
    л
    ь
    т
    у
    р
    н
    о
    г
    о
    н
    а
    с
    л
    е
    д
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, special_use_boundary=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 special_use_boundary is None:
            self.special_use_boundary = []
        else:
            self.special_use_boundary = special_use_boundary
        self.special_use_boundary_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpecialUseBoundaries)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpecialUseBoundaries.subclass:
            return SpecialUseBoundaries.subclass(*args_, **kwargs_)
        else:
            return SpecialUseBoundaries(*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_special_use_boundary(self):
        return self.special_use_boundary
    def set_special_use_boundary(self, special_use_boundary):
        self.special_use_boundary = special_use_boundary
    def add_special_use_boundary(self, value):
        self.special_use_boundary.append(value)
    def insert_special_use_boundary_at(self, index, value):
        self.special_use_boundary.insert(index, value)
    def replace_special_use_boundary_at(self, index, value):
        self.special_use_boundary[index] = value
    def has__content(self):
        if (
            self.special_use_boundary
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecialUseBoundaries', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpecialUseBoundaries')
        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_ == 'SpecialUseBoundaries':
            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_='SpecialUseBoundaries')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpecialUseBoundaries', 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_='SpecialUseBoundaries'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecialUseBoundaries', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for special_use_boundary_ in self.special_use_boundary:
            namespaceprefix_ = self.special_use_boundary_nsprefix_ + ':' if (UseCapturedNS_ and self.special_use_boundary_nsprefix_) else ''
            special_use_boundary_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='special_use_boundary', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'special_use_boundary':
            obj_ = RegNumbBorder.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.special_use_boundary.append(obj_)
            obj_.original_tagname_ = 'special_use_boundary'
# end class SpecialUseBoundaries


class GuardedNaturalBoundaries(GeneratedsSuper):
    """GuardedNaturalBoundaries -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    о
    с
    о
    б
    о
    о
    х
    р
    а
    н
    я
    е
    м
    о
    й
    п
    р
    и
    р
    о
    д
    н
    о
    й
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    ,
    о
    х
    о
    т
    н
    и
    ч
    ь
    и
    х
    у
    г
    о
    д
    и
    й
    ,
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    ,
    л
    е
    с
    о
    п
    а
    р
    к
    о
    в
    guarded_natural_boundary -- О
    с
    о
    б
    о
    о
    х
    р
    а
    н
    я
    е
    м
    а
    я
    п
    р
    и
    р
    о
    д
    н
    а
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    я
    ,
    о
    х
    о
    т
    н
    и
    ч
    ь
    и
    у
    г
    о
    д
    ь
    я
    ,
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    о
    ,
    л
    е
    с
    о
    п
    а
    р
    к
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, guarded_natural_boundary=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 guarded_natural_boundary is None:
            self.guarded_natural_boundary = []
        else:
            self.guarded_natural_boundary = guarded_natural_boundary
        self.guarded_natural_boundary_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, GuardedNaturalBoundaries)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if GuardedNaturalBoundaries.subclass:
            return GuardedNaturalBoundaries.subclass(*args_, **kwargs_)
        else:
            return GuardedNaturalBoundaries(*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_guarded_natural_boundary(self):
        return self.guarded_natural_boundary
    def set_guarded_natural_boundary(self, guarded_natural_boundary):
        self.guarded_natural_boundary = guarded_natural_boundary
    def add_guarded_natural_boundary(self, value):
        self.guarded_natural_boundary.append(value)
    def insert_guarded_natural_boundary_at(self, index, value):
        self.guarded_natural_boundary.insert(index, value)
    def replace_guarded_natural_boundary_at(self, index, value):
        self.guarded_natural_boundary[index] = value
    def has__content(self):
        if (
            self.guarded_natural_boundary
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='GuardedNaturalBoundaries', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('GuardedNaturalBoundaries')
        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_ == 'GuardedNaturalBoundaries':
            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_='GuardedNaturalBoundaries')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GuardedNaturalBoundaries', 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_='GuardedNaturalBoundaries'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='GuardedNaturalBoundaries', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for guarded_natural_boundary_ in self.guarded_natural_boundary:
            namespaceprefix_ = self.guarded_natural_boundary_nsprefix_ + ':' if (UseCapturedNS_ and self.guarded_natural_boundary_nsprefix_) else ''
            guarded_natural_boundary_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='guarded_natural_boundary', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'guarded_natural_boundary':
            obj_ = RegNumbBorder.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.guarded_natural_boundary.append(obj_)
            obj_.original_tagname_ = 'guarded_natural_boundary'
# end class GuardedNaturalBoundaries


class LandRecordsContoursLocation(GeneratedsSuper):
    """LandRecordsContoursLocation -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    )
    land_record -- З
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_record=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 land_record is None:
            self.land_record = []
        else:
            self.land_record = land_record
        self.land_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LandRecordsContoursLocation)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LandRecordsContoursLocation.subclass:
            return LandRecordsContoursLocation.subclass(*args_, **kwargs_)
        else:
            return LandRecordsContoursLocation(*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_land_record(self):
        return self.land_record
    def set_land_record(self, land_record):
        self.land_record = land_record
    def add_land_record(self, value):
        self.land_record.append(value)
    def insert_land_record_at(self, index, value):
        self.land_record.insert(index, value)
    def replace_land_record_at(self, index, value):
        self.land_record[index] = value
    def has__content(self):
        if (
            self.land_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandRecordsContoursLocation', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LandRecordsContoursLocation')
        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_ == 'LandRecordsContoursLocation':
            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_='LandRecordsContoursLocation')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LandRecordsContoursLocation', 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_='LandRecordsContoursLocation'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandRecordsContoursLocation', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for land_record_ in self.land_record:
            namespaceprefix_ = self.land_record_nsprefix_ + ':' if (UseCapturedNS_ and self.land_record_nsprefix_) else ''
            land_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_record':
            obj_ = ContoursLocationZUOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_record.append(obj_)
            obj_.original_tagname_ = 'land_record'
# end class LandRecordsContoursLocation


class BuildRecordsContoursLocation(GeneratedsSuper):
    """BuildRecordsContoursLocation -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    з
    д
    а
    н
    и
    я
    (
    з
    д
    а
    н
    и
    й
    )
    build_record -- З
    д
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, build_record=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 build_record is None:
            self.build_record = []
        else:
            self.build_record = build_record
        self.build_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BuildRecordsContoursLocation)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BuildRecordsContoursLocation.subclass:
            return BuildRecordsContoursLocation.subclass(*args_, **kwargs_)
        else:
            return BuildRecordsContoursLocation(*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_build_record(self):
        return self.build_record
    def set_build_record(self, build_record):
        self.build_record = build_record
    def add_build_record(self, value):
        self.build_record.append(value)
    def insert_build_record_at(self, index, value):
        self.build_record.insert(index, value)
    def replace_build_record_at(self, index, value):
        self.build_record[index] = value
    def has__content(self):
        if (
            self.build_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuildRecordsContoursLocation', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BuildRecordsContoursLocation')
        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_ == 'BuildRecordsContoursLocation':
            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_='BuildRecordsContoursLocation')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BuildRecordsContoursLocation', 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_='BuildRecordsContoursLocation'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuildRecordsContoursLocation', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for build_record_ in self.build_record:
            namespaceprefix_ = self.build_record_nsprefix_ + ':' if (UseCapturedNS_ and self.build_record_nsprefix_) else ''
            build_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='build_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'build_record':
            obj_ = ContoursLocationOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.build_record.append(obj_)
            obj_.original_tagname_ = 'build_record'
# end class BuildRecordsContoursLocation


class ConstructionRecordsContoursLocation(GeneratedsSuper):
    """ConstructionRecordsContoursLocation -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    (
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    й
    )
    construction_record -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, construction_record=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 construction_record is None:
            self.construction_record = []
        else:
            self.construction_record = construction_record
        self.construction_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ConstructionRecordsContoursLocation)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ConstructionRecordsContoursLocation.subclass:
            return ConstructionRecordsContoursLocation.subclass(*args_, **kwargs_)
        else:
            return ConstructionRecordsContoursLocation(*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_construction_record(self):
        return self.construction_record
    def set_construction_record(self, construction_record):
        self.construction_record = construction_record
    def add_construction_record(self, value):
        self.construction_record.append(value)
    def insert_construction_record_at(self, index, value):
        self.construction_record.insert(index, value)
    def replace_construction_record_at(self, index, value):
        self.construction_record[index] = value
    def has__content(self):
        if (
            self.construction_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ConstructionRecordsContoursLocation', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ConstructionRecordsContoursLocation')
        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_ == 'ConstructionRecordsContoursLocation':
            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_='ConstructionRecordsContoursLocation')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ConstructionRecordsContoursLocation', 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_='ConstructionRecordsContoursLocation'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ConstructionRecordsContoursLocation', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for construction_record_ in self.construction_record:
            namespaceprefix_ = self.construction_record_nsprefix_ + ':' if (UseCapturedNS_ and self.construction_record_nsprefix_) else ''
            construction_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='construction_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'construction_record':
            obj_ = ContoursLocationOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.construction_record.append(obj_)
            obj_.original_tagname_ = 'construction_record'
# end class ConstructionRecordsContoursLocation


class BuildRecordsContoursAdditional(GeneratedsSuper):
    """BuildRecordsContoursAdditional -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    з
    д
    а
    н
    и
    я
    (
    з
    д
    а
    н
    и
    й
    ) (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    о
    е
    п
    р
    о
    с
    т
    р
    а
    н
    с
    т
    в
    е
    н
    н
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    к
    о
    н
    с
    т
    р
    у
    к
    т
    и
    в
    н
    ы
    х
    э
    л
    е
    м
    е
    н
    т
    о
    в
    )
    build_record -- З
    д
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, build_record=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 build_record is None:
            self.build_record = []
        else:
            self.build_record = build_record
        self.build_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BuildRecordsContoursAdditional)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BuildRecordsContoursAdditional.subclass:
            return BuildRecordsContoursAdditional.subclass(*args_, **kwargs_)
        else:
            return BuildRecordsContoursAdditional(*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_build_record(self):
        return self.build_record
    def set_build_record(self, build_record):
        self.build_record = build_record
    def add_build_record(self, value):
        self.build_record.append(value)
    def insert_build_record_at(self, index, value):
        self.build_record.insert(index, value)
    def replace_build_record_at(self, index, value):
        self.build_record[index] = value
    def has__content(self):
        if (
            self.build_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuildRecordsContoursAdditional', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BuildRecordsContoursAdditional')
        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_ == 'BuildRecordsContoursAdditional':
            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_='BuildRecordsContoursAdditional')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BuildRecordsContoursAdditional', 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_='BuildRecordsContoursAdditional'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuildRecordsContoursAdditional', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for build_record_ in self.build_record:
            namespaceprefix_ = self.build_record_nsprefix_ + ':' if (UseCapturedNS_ and self.build_record_nsprefix_) else ''
            build_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='build_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'build_record':
            obj_ = ContoursLocationAdditionalOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.build_record.append(obj_)
            obj_.original_tagname_ = 'build_record'
# end class BuildRecordsContoursAdditional


class ConstructionRecordsContoursAdditional(GeneratedsSuper):
    """ConstructionRecordsContoursAdditional -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    (
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    й
    ) (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    о
    е
    п
    р
    о
    с
    т
    р
    а
    н
    с
    т
    в
    е
    н
    н
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    к
    о
    н
    с
    т
    р
    у
    к
    т
    и
    в
    н
    ы
    х
    э
    л
    е
    м
    е
    н
    т
    о
    в
    )
    construction_record -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, construction_record=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 construction_record is None:
            self.construction_record = []
        else:
            self.construction_record = construction_record
        self.construction_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ConstructionRecordsContoursAdditional)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ConstructionRecordsContoursAdditional.subclass:
            return ConstructionRecordsContoursAdditional.subclass(*args_, **kwargs_)
        else:
            return ConstructionRecordsContoursAdditional(*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_construction_record(self):
        return self.construction_record
    def set_construction_record(self, construction_record):
        self.construction_record = construction_record
    def add_construction_record(self, value):
        self.construction_record.append(value)
    def insert_construction_record_at(self, index, value):
        self.construction_record.insert(index, value)
    def replace_construction_record_at(self, index, value):
        self.construction_record[index] = value
    def has__content(self):
        if (
            self.construction_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ConstructionRecordsContoursAdditional', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ConstructionRecordsContoursAdditional')
        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_ == 'ConstructionRecordsContoursAdditional':
            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_='ConstructionRecordsContoursAdditional')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ConstructionRecordsContoursAdditional', 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_='ConstructionRecordsContoursAdditional'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ConstructionRecordsContoursAdditional', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for construction_record_ in self.construction_record:
            namespaceprefix_ = self.construction_record_nsprefix_ + ':' if (UseCapturedNS_ and self.construction_record_nsprefix_) else ''
            construction_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='construction_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'construction_record':
            obj_ = ContoursLocationAdditionalOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.construction_record.append(obj_)
            obj_.original_tagname_ = 'construction_record'
# end class ConstructionRecordsContoursAdditional


class ContoursLocationAdditionalOKSOut(GeneratedsSuper):
    """ContoursLocationAdditionalOKSOut -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    о
    е
    п
    р
    о
    с
    т
    р
    а
    н
    с
    т
    в
    е
    н
    н
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    к
    о
    н
    с
    т
    р
    у
    к
    т
    и
    в
    н
    ы
    х
    э
    л
    е
    м
    е
    н
    т
    о
    в
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    contours -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    additional_contour_location -- Д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    о
    е
    п
    р
    о
    с
    т
    р
    а
    н
    с
    т
    в
    е
    н
    н
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    к
    о
    н
    с
    т
    р
    у
    к
    т
    и
    в
    н
    ы
    х
    э
    л
    е
    м
    е
    н
    т
    о
    в
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, contours=None, additional_contour_location=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.object = object
        self.object_nsprefix_ = None
        self.contours = contours
        self.contours_nsprefix_ = None
        self.additional_contour_location = additional_contour_location
        self.additional_contour_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContoursLocationAdditionalOKSOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContoursLocationAdditionalOKSOut.subclass:
            return ContoursLocationAdditionalOKSOut.subclass(*args_, **kwargs_)
        else:
            return ContoursLocationAdditionalOKSOut(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def get_additional_contour_location(self):
        return self.additional_contour_location
    def set_additional_contour_location(self, additional_contour_location):
        self.additional_contour_location = additional_contour_location
    def has__content(self):
        if (
            self.object is not None or
            self.contours is not None or
            self.additional_contour_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursLocationAdditionalOKSOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContoursLocationAdditionalOKSOut')
        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_ == 'ContoursLocationAdditionalOKSOut':
            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_='ContoursLocationAdditionalOKSOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContoursLocationAdditionalOKSOut', 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_='ContoursLocationAdditionalOKSOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursLocationAdditionalOKSOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', pretty_print=pretty_print)
        if self.additional_contour_location is not None:
            namespaceprefix_ = self.additional_contour_location_nsprefix_ + ':' if (UseCapturedNS_ and self.additional_contour_location_nsprefix_) else ''
            self.additional_contour_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='additional_contour_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectCadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'contours':
            obj_ = ContoursOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
        elif nodeName_ == 'additional_contour_location':
            obj_ = AdditionalContourLocationOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.additional_contour_location = obj_
            obj_.original_tagname_ = 'additional_contour_location'
# end class ContoursLocationAdditionalOKSOut


class ObjectPartsNumberRestrictions(GeneratedsSuper):
    """ObjectPartsNumberRestrictions -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    object_part -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object_part=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 object_part is None:
            self.object_part = []
        else:
            self.object_part = object_part
        self.object_part_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectPartsNumberRestrictions)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectPartsNumberRestrictions.subclass:
            return ObjectPartsNumberRestrictions.subclass(*args_, **kwargs_)
        else:
            return ObjectPartsNumberRestrictions(*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_object_part(self):
        return self.object_part
    def set_object_part(self, object_part):
        self.object_part = object_part
    def add_object_part(self, value):
        self.object_part.append(value)
    def insert_object_part_at(self, index, value):
        self.object_part.insert(index, value)
    def replace_object_part_at(self, index, value):
        self.object_part[index] = value
    def has__content(self):
        if (
            self.object_part
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectPartsNumberRestrictions', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectPartsNumberRestrictions')
        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_ == 'ObjectPartsNumberRestrictions':
            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_='ObjectPartsNumberRestrictions')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectPartsNumberRestrictions', 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_='ObjectPartsNumberRestrictions'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectPartsNumberRestrictions', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for object_part_ in self.object_part:
            namespaceprefix_ = self.object_part_nsprefix_ + ':' if (UseCapturedNS_ and self.object_part_nsprefix_) else ''
            object_part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_part', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object_part':
            obj_ = ObjectPartNumberRestrictions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_part.append(obj_)
            obj_.original_tagname_ = 'object_part'
# end class ObjectPartsNumberRestrictions


class ObjectPartNumberRestrictions(GeneratedsSuper):
    """ObjectPartNumberRestrictions -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    н
    о
    м
    е
    р
    ,
    с
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    й
    )
    part_number -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    content_restrictions -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    й
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, part_number=None, content_restrictions=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.part_number = part_number
        self.part_number_nsprefix_ = None
        self.content_restrictions = content_restrictions
        self.content_restrictions_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectPartNumberRestrictions)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectPartNumberRestrictions.subclass:
            return ObjectPartNumberRestrictions.subclass(*args_, **kwargs_)
        else:
            return ObjectPartNumberRestrictions(*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_part_number(self):
        return self.part_number
    def set_part_number(self, part_number):
        self.part_number = part_number
    def get_content_restrictions(self):
        return self.content_restrictions
    def set_content_restrictions(self, content_restrictions):
        self.content_restrictions = content_restrictions
    def has__content(self):
        if (
            self.part_number is not None or
            self.content_restrictions is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectPartNumberRestrictions', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectPartNumberRestrictions')
        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_ == 'ObjectPartNumberRestrictions':
            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_='ObjectPartNumberRestrictions')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectPartNumberRestrictions', 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_='ObjectPartNumberRestrictions'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectPartNumberRestrictions', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.part_number is not None:
            namespaceprefix_ = self.part_number_nsprefix_ + ':' if (UseCapturedNS_ and self.part_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spart_number>%s</%spart_number>%s' % (namespaceprefix_ , self.gds_format_integer(self.part_number, input_name='part_number'), namespaceprefix_ , eol_))
        if self.content_restrictions is not None:
            namespaceprefix_ = self.content_restrictions_nsprefix_ + ':' if (UseCapturedNS_ and self.content_restrictions_nsprefix_) else ''
            self.content_restrictions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='content_restrictions', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'part_number' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'part_number')
            ival_ = self.gds_validate_integer(ival_, node, 'part_number')
            self.part_number = ival_
            self.part_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'content_restrictions':
            obj_ = ContentRestrictions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.content_restrictions = obj_
            obj_.original_tagname_ = 'content_restrictions'
# end class ObjectPartNumberRestrictions


class ObjectPartsAreaRestrictions(GeneratedsSuper):
    """ObjectPartsAreaRestrictions -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    н
    о
    м
    е
    р
    ,
    п
    л
    о
    щ
    а
    д
    ь
    ,
    с
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    й
    )
    object_part -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object_part=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 object_part is None:
            self.object_part = []
        else:
            self.object_part = object_part
        self.object_part_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectPartsAreaRestrictions)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectPartsAreaRestrictions.subclass:
            return ObjectPartsAreaRestrictions.subclass(*args_, **kwargs_)
        else:
            return ObjectPartsAreaRestrictions(*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_object_part(self):
        return self.object_part
    def set_object_part(self, object_part):
        self.object_part = object_part
    def add_object_part(self, value):
        self.object_part.append(value)
    def insert_object_part_at(self, index, value):
        self.object_part.insert(index, value)
    def replace_object_part_at(self, index, value):
        self.object_part[index] = value
    def has__content(self):
        if (
            self.object_part
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectPartsAreaRestrictions', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectPartsAreaRestrictions')
        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_ == 'ObjectPartsAreaRestrictions':
            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_='ObjectPartsAreaRestrictions')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectPartsAreaRestrictions', 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_='ObjectPartsAreaRestrictions'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectPartsAreaRestrictions', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for object_part_ in self.object_part:
            namespaceprefix_ = self.object_part_nsprefix_ + ':' if (UseCapturedNS_ and self.object_part_nsprefix_) else ''
            object_part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_part', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object_part':
            obj_ = object_partType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_part.append(obj_)
            obj_.original_tagname_ = 'object_part'
# end class ObjectPartsAreaRestrictions


class BuildPartsProperty(GeneratedsSuper):
    """BuildPartsProperty -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    я
    х
    з
    д
    а
    н
    и
    я
    (
    и
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    ч
    а
    с
    т
    и
    )
    object_part -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    з
    д
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object_part=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 object_part is None:
            self.object_part = []
        else:
            self.object_part = object_part
        self.object_part_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BuildPartsProperty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BuildPartsProperty.subclass:
            return BuildPartsProperty.subclass(*args_, **kwargs_)
        else:
            return BuildPartsProperty(*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_object_part(self):
        return self.object_part
    def set_object_part(self, object_part):
        self.object_part = object_part
    def add_object_part(self, value):
        self.object_part.append(value)
    def insert_object_part_at(self, index, value):
        self.object_part.insert(index, value)
    def replace_object_part_at(self, index, value):
        self.object_part[index] = value
    def has__content(self):
        if (
            self.object_part
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuildPartsProperty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BuildPartsProperty')
        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_ == 'BuildPartsProperty':
            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_='BuildPartsProperty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BuildPartsProperty', 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_='BuildPartsProperty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuildPartsProperty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for object_part_ in self.object_part:
            namespaceprefix_ = self.object_part_nsprefix_ + ':' if (UseCapturedNS_ and self.object_part_nsprefix_) else ''
            object_part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_part', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object_part':
            obj_ = BuildPartProperty.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_part.append(obj_)
            obj_.original_tagname_ = 'object_part'
# end class BuildPartsProperty


class BuildPartProperty(GeneratedsSuper):
    """BuildPartProperty -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    з
    д
    а
    н
    и
    я
    (
    и
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    ч
    а
    с
    т
    и
    )
    part_number -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    area -- П
    л
    о
    щ
    а
    д
    ь
    ,
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    location_building -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    ч
    а
    с
    т
    и
    з
    д
    а
    н
    и
    я
    content_restrictions -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    й
    (
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    ы
    х
    )
    footnote -- П
    р
    и
    м
    е
    ч
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, part_number=None, area=None, location_building=None, content_restrictions=None, footnote=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.part_number = part_number
        self.part_number_nsprefix_ = None
        self.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.location_building = location_building
        self.location_building_nsprefix_ = None
        self.content_restrictions = content_restrictions
        self.content_restrictions_nsprefix_ = None
        self.footnote = footnote
        self.footnote_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BuildPartProperty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BuildPartProperty.subclass:
            return BuildPartProperty.subclass(*args_, **kwargs_)
        else:
            return BuildPartProperty(*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_part_number(self):
        return self.part_number
    def set_part_number(self, part_number):
        self.part_number = part_number
    def get_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_location_building(self):
        return self.location_building
    def set_location_building(self, location_building):
        self.location_building = location_building
    def get_content_restrictions(self):
        return self.content_restrictions
    def set_content_restrictions(self, content_restrictions):
        self.content_restrictions = content_restrictions
    def get_footnote(self):
        return self.footnote
    def set_footnote(self, footnote):
        self.footnote = footnote
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.part_number is not None or
            self.area is not None or
            self.location_building is not None or
            self.content_restrictions is not None or
            self.footnote is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuildPartProperty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BuildPartProperty')
        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_ == 'BuildPartProperty':
            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_='BuildPartProperty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BuildPartProperty', 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_='BuildPartProperty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuildPartProperty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.part_number is not None:
            namespaceprefix_ = self.part_number_nsprefix_ + ':' if (UseCapturedNS_ and self.part_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spart_number>%s</%spart_number>%s' % (namespaceprefix_ , self.gds_format_integer(self.part_number, input_name='part_number'), namespaceprefix_ , eol_))
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.location_building is not None:
            namespaceprefix_ = self.location_building_nsprefix_ + ':' if (UseCapturedNS_ and self.location_building_nsprefix_) else ''
            self.location_building.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location_building', pretty_print=pretty_print)
        if self.content_restrictions is not None:
            namespaceprefix_ = self.content_restrictions_nsprefix_ + ':' if (UseCapturedNS_ and self.content_restrictions_nsprefix_) else ''
            self.content_restrictions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='content_restrictions', pretty_print=pretty_print)
        if self.footnote is not None:
            namespaceprefix_ = self.footnote_nsprefix_ + ':' if (UseCapturedNS_ and self.footnote_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfootnote>%s</%sfootnote>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.footnote), input_name='footnote')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'part_number' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'part_number')
            ival_ = self.gds_validate_integer(ival_, node, 'part_number')
            self.part_number = ival_
            self.part_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'location_building':
            obj_ = LocationInBuildContours.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.location_building = obj_
            obj_.original_tagname_ = 'location_building'
        elif nodeName_ == 'content_restrictions':
            obj_ = ContentRestrictions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.content_restrictions = obj_
            obj_.original_tagname_ = 'content_restrictions'
        elif nodeName_ == 'footnote':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'footnote')
            value_ = self.gds_validate_string(value_, node, 'footnote')
            self.footnote = value_
            self.footnote_nsprefix_ = child_.prefix
# end class BuildPartProperty


class RoomPartsProperty(GeneratedsSuper):
    """RoomPartsProperty -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    я
    х
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    (
    и
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    ч
    а
    с
    т
    и
    )
    object_part -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object_part=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 object_part is None:
            self.object_part = []
        else:
            self.object_part = object_part
        self.object_part_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomPartsProperty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomPartsProperty.subclass:
            return RoomPartsProperty.subclass(*args_, **kwargs_)
        else:
            return RoomPartsProperty(*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_object_part(self):
        return self.object_part
    def set_object_part(self, object_part):
        self.object_part = object_part
    def add_object_part(self, value):
        self.object_part.append(value)
    def insert_object_part_at(self, index, value):
        self.object_part.insert(index, value)
    def replace_object_part_at(self, index, value):
        self.object_part[index] = value
    def has__content(self):
        if (
            self.object_part
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomPartsProperty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomPartsProperty')
        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_ == 'RoomPartsProperty':
            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_='RoomPartsProperty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomPartsProperty', 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_='RoomPartsProperty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomPartsProperty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for object_part_ in self.object_part:
            namespaceprefix_ = self.object_part_nsprefix_ + ':' if (UseCapturedNS_ and self.object_part_nsprefix_) else ''
            object_part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_part', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object_part':
            obj_ = RoomPartProperty.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_part.append(obj_)
            obj_.original_tagname_ = 'object_part'
# end class RoomPartsProperty


class RoomPartProperty(GeneratedsSuper):
    """RoomPartProperty -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    (
    и
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    ч
    а
    с
    т
    и
    )
    part_number -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    in_build -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    п
    р
    е
    д
    е
    л
    а
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    )
    area -- П
    л
    о
    щ
    а
    д
    ь
    ,
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    content_restrictions -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    й
    (
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    ы
    х
    )
    footnote -- П
    р
    и
    м
    е
    ч
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, part_number=None, in_build=None, area=None, content_restrictions=None, footnote=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.part_number = part_number
        self.part_number_nsprefix_ = None
        self.in_build = in_build
        self.in_build_nsprefix_ = None
        self.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.content_restrictions = content_restrictions
        self.content_restrictions_nsprefix_ = None
        self.footnote = footnote
        self.footnote_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomPartProperty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomPartProperty.subclass:
            return RoomPartProperty.subclass(*args_, **kwargs_)
        else:
            return RoomPartProperty(*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_part_number(self):
        return self.part_number
    def set_part_number(self, part_number):
        self.part_number = part_number
    def get_in_build(self):
        return self.in_build
    def set_in_build(self, in_build):
        self.in_build = in_build
    def get_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_content_restrictions(self):
        return self.content_restrictions
    def set_content_restrictions(self, content_restrictions):
        self.content_restrictions = content_restrictions
    def get_footnote(self):
        return self.footnote
    def set_footnote(self, footnote):
        self.footnote = footnote
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.part_number is not None or
            self.in_build is not None or
            self.area is not None or
            self.content_restrictions is not None or
            self.footnote is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomPartProperty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomPartProperty')
        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_ == 'RoomPartProperty':
            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_='RoomPartProperty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomPartProperty', 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_='RoomPartProperty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomPartProperty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.part_number is not None:
            namespaceprefix_ = self.part_number_nsprefix_ + ':' if (UseCapturedNS_ and self.part_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spart_number>%s</%spart_number>%s' % (namespaceprefix_ , self.gds_format_integer(self.part_number, input_name='part_number'), namespaceprefix_ , eol_))
        if self.in_build is not None:
            namespaceprefix_ = self.in_build_nsprefix_ + ':' if (UseCapturedNS_ and self.in_build_nsprefix_) else ''
            self.in_build.export(outfile, level, namespaceprefix_, namespacedef_='', name_='in_build', pretty_print=pretty_print)
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.content_restrictions is not None:
            namespaceprefix_ = self.content_restrictions_nsprefix_ + ':' if (UseCapturedNS_ and self.content_restrictions_nsprefix_) else ''
            self.content_restrictions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='content_restrictions', pretty_print=pretty_print)
        if self.footnote is not None:
            namespaceprefix_ = self.footnote_nsprefix_ + ':' if (UseCapturedNS_ and self.footnote_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfootnote>%s</%sfootnote>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.footnote), input_name='footnote')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'part_number' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'part_number')
            ival_ = self.gds_validate_integer(ival_, node, 'part_number')
            self.part_number = ival_
            self.part_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'in_build':
            obj_ = LocationInBuild.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.in_build = obj_
            obj_.original_tagname_ = 'in_build'
        elif nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'content_restrictions':
            obj_ = ContentRestrictions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.content_restrictions = obj_
            obj_.original_tagname_ = 'content_restrictions'
        elif nodeName_ == 'footnote':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'footnote')
            value_ = self.gds_validate_string(value_, node, 'footnote')
            self.footnote = value_
            self.footnote_nsprefix_ = child_.prefix
# end class RoomPartProperty


class ConstructionPartsProperty(GeneratedsSuper):
    """ConstructionPartsProperty -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    я
    х
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    (
    и
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    ч
    а
    с
    т
    и
    )
    object_part -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object_part=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 object_part is None:
            self.object_part = []
        else:
            self.object_part = object_part
        self.object_part_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ConstructionPartsProperty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ConstructionPartsProperty.subclass:
            return ConstructionPartsProperty.subclass(*args_, **kwargs_)
        else:
            return ConstructionPartsProperty(*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_object_part(self):
        return self.object_part
    def set_object_part(self, object_part):
        self.object_part = object_part
    def add_object_part(self, value):
        self.object_part.append(value)
    def insert_object_part_at(self, index, value):
        self.object_part.insert(index, value)
    def replace_object_part_at(self, index, value):
        self.object_part[index] = value
    def has__content(self):
        if (
            self.object_part
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ConstructionPartsProperty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ConstructionPartsProperty')
        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_ == 'ConstructionPartsProperty':
            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_='ConstructionPartsProperty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ConstructionPartsProperty', 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_='ConstructionPartsProperty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ConstructionPartsProperty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for object_part_ in self.object_part:
            namespaceprefix_ = self.object_part_nsprefix_ + ':' if (UseCapturedNS_ and self.object_part_nsprefix_) else ''
            object_part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_part', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object_part':
            obj_ = ConstructionPartProperty.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_part.append(obj_)
            obj_.original_tagname_ = 'object_part'
# end class ConstructionPartsProperty


class ConstructionPartProperty(GeneratedsSuper):
    """ConstructionPartProperty -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    (
    и
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    ч
    а
    с
    т
    и
    )
    part_number -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    base_parameters -- О
    с
    н
    о
    в
    н
    ы
    е
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    location_building -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    ч
    а
    с
    т
    и
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    content_restrictions -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    й
    (
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    ы
    х
    )
    footnote -- П
    р
    и
    м
    е
    ч
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, part_number=None, base_parameters=None, location_building=None, content_restrictions=None, footnote=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.part_number = part_number
        self.part_number_nsprefix_ = None
        self.base_parameters = base_parameters
        self.base_parameters_nsprefix_ = None
        self.location_building = location_building
        self.location_building_nsprefix_ = None
        self.content_restrictions = content_restrictions
        self.content_restrictions_nsprefix_ = None
        self.footnote = footnote
        self.footnote_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ConstructionPartProperty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ConstructionPartProperty.subclass:
            return ConstructionPartProperty.subclass(*args_, **kwargs_)
        else:
            return ConstructionPartProperty(*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_part_number(self):
        return self.part_number
    def set_part_number(self, part_number):
        self.part_number = part_number
    def get_base_parameters(self):
        return self.base_parameters
    def set_base_parameters(self, base_parameters):
        self.base_parameters = base_parameters
    def get_location_building(self):
        return self.location_building
    def set_location_building(self, location_building):
        self.location_building = location_building
    def get_content_restrictions(self):
        return self.content_restrictions
    def set_content_restrictions(self, content_restrictions):
        self.content_restrictions = content_restrictions
    def get_footnote(self):
        return self.footnote
    def set_footnote(self, footnote):
        self.footnote = footnote
    def has__content(self):
        if (
            self.part_number is not None or
            self.base_parameters is not None or
            self.location_building is not None or
            self.content_restrictions is not None or
            self.footnote is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ConstructionPartProperty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ConstructionPartProperty')
        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_ == 'ConstructionPartProperty':
            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_='ConstructionPartProperty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ConstructionPartProperty', 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_='ConstructionPartProperty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ConstructionPartProperty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.part_number is not None:
            namespaceprefix_ = self.part_number_nsprefix_ + ':' if (UseCapturedNS_ and self.part_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spart_number>%s</%spart_number>%s' % (namespaceprefix_ , self.gds_format_integer(self.part_number, input_name='part_number'), namespaceprefix_ , eol_))
        if self.base_parameters is not None:
            namespaceprefix_ = self.base_parameters_nsprefix_ + ':' if (UseCapturedNS_ and self.base_parameters_nsprefix_) else ''
            self.base_parameters.export(outfile, level, namespaceprefix_, namespacedef_='', name_='base_parameters', pretty_print=pretty_print)
        if self.location_building is not None:
            namespaceprefix_ = self.location_building_nsprefix_ + ':' if (UseCapturedNS_ and self.location_building_nsprefix_) else ''
            self.location_building.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location_building', pretty_print=pretty_print)
        if self.content_restrictions is not None:
            namespaceprefix_ = self.content_restrictions_nsprefix_ + ':' if (UseCapturedNS_ and self.content_restrictions_nsprefix_) else ''
            self.content_restrictions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='content_restrictions', pretty_print=pretty_print)
        if self.footnote is not None:
            namespaceprefix_ = self.footnote_nsprefix_ + ':' if (UseCapturedNS_ and self.footnote_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfootnote>%s</%sfootnote>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.footnote), input_name='footnote')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'part_number' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'part_number')
            ival_ = self.gds_validate_integer(ival_, node, 'part_number')
            self.part_number = ival_
            self.part_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'base_parameters':
            obj_ = BaseParameters.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.base_parameters = obj_
            obj_.original_tagname_ = 'base_parameters'
        elif nodeName_ == 'location_building':
            obj_ = LocationLevelsContours.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.location_building = obj_
            obj_.original_tagname_ = 'location_building'
        elif nodeName_ == 'content_restrictions':
            obj_ = ContentRestrictions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.content_restrictions = obj_
            obj_.original_tagname_ = 'content_restrictions'
        elif nodeName_ == 'footnote':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'footnote')
            value_ = self.gds_validate_string(value_, node, 'footnote')
            self.footnote = value_
            self.footnote_nsprefix_ = child_.prefix
# end class ConstructionPartProperty


class LandPartsProperty(GeneratedsSuper):
    """LandPartsProperty -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    я
    х
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    и
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    ч
    а
    с
    т
    и
    )
    object_part -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object_part=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 object_part is None:
            self.object_part = []
        else:
            self.object_part = object_part
        self.object_part_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LandPartsProperty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LandPartsProperty.subclass:
            return LandPartsProperty.subclass(*args_, **kwargs_)
        else:
            return LandPartsProperty(*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_object_part(self):
        return self.object_part
    def set_object_part(self, object_part):
        self.object_part = object_part
    def add_object_part(self, value):
        self.object_part.append(value)
    def insert_object_part_at(self, index, value):
        self.object_part.insert(index, value)
    def replace_object_part_at(self, index, value):
        self.object_part[index] = value
    def has__content(self):
        if (
            self.object_part
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandPartsProperty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LandPartsProperty')
        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_ == 'LandPartsProperty':
            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_='LandPartsProperty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LandPartsProperty', 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_='LandPartsProperty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandPartsProperty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for object_part_ in self.object_part:
            namespaceprefix_ = self.object_part_nsprefix_ + ':' if (UseCapturedNS_ and self.object_part_nsprefix_) else ''
            object_part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_part', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object_part':
            obj_ = LandPartProperty.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_part.append(obj_)
            obj_.original_tagname_ = 'object_part'
# end class LandPartsProperty


class LandPartProperty(GeneratedsSuper):
    """LandPartProperty -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    и
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    ч
    а
    с
    т
    и
    )
    part_number -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    contours -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    area -- П
    л
    о
    щ
    а
    д
    ь
    content_restrictions -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    й
    footnote -- П
    р
    и
    м
    е
    ч
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, part_number=None, contours=None, area=None, content_restrictions=None, footnote=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.part_number = part_number
        self.part_number_nsprefix_ = None
        self.contours = contours
        self.contours_nsprefix_ = None
        self.area = area
        self.area_nsprefix_ = None
        self.content_restrictions = content_restrictions
        self.content_restrictions_nsprefix_ = None
        self.footnote = footnote
        self.footnote_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LandPartProperty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LandPartProperty.subclass:
            return LandPartProperty.subclass(*args_, **kwargs_)
        else:
            return LandPartProperty(*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_part_number(self):
        return self.part_number
    def set_part_number(self, part_number):
        self.part_number = part_number
    def get_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def get_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_content_restrictions(self):
        return self.content_restrictions
    def set_content_restrictions(self, content_restrictions):
        self.content_restrictions = content_restrictions
    def get_footnote(self):
        return self.footnote
    def set_footnote(self, footnote):
        self.footnote = footnote
    def has__content(self):
        if (
            self.part_number is not None or
            self.contours is not None or
            self.area is not None or
            self.content_restrictions is not None or
            self.footnote is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandPartProperty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LandPartProperty')
        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_ == 'LandPartProperty':
            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_='LandPartProperty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LandPartProperty', 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_='LandPartProperty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandPartProperty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.part_number is not None:
            namespaceprefix_ = self.part_number_nsprefix_ + ':' if (UseCapturedNS_ and self.part_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spart_number>%s</%spart_number>%s' % (namespaceprefix_ , self.gds_format_integer(self.part_number, input_name='part_number'), namespaceprefix_ , eol_))
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', pretty_print=pretty_print)
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            self.area.export(outfile, level, namespaceprefix_, namespacedef_='', name_='area', pretty_print=pretty_print)
        if self.content_restrictions is not None:
            namespaceprefix_ = self.content_restrictions_nsprefix_ + ':' if (UseCapturedNS_ and self.content_restrictions_nsprefix_) else ''
            self.content_restrictions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='content_restrictions', pretty_print=pretty_print)
        if self.footnote is not None:
            namespaceprefix_ = self.footnote_nsprefix_ + ':' if (UseCapturedNS_ and self.footnote_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfootnote>%s</%sfootnote>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.footnote), input_name='footnote')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'part_number' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'part_number')
            ival_ = self.gds_validate_integer(ival_, node, 'part_number')
            self.part_number = ival_
            self.part_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'contours':
            obj_ = ContoursZUZacrep.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
        elif nodeName_ == 'area':
            obj_ = LandArea.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.area = obj_
            obj_.original_tagname_ = 'area'
        elif nodeName_ == 'content_restrictions':
            obj_ = ContentRestrictions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.content_restrictions = obj_
            obj_.original_tagname_ = 'content_restrictions'
        elif nodeName_ == 'footnote':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'footnote')
            value_ = self.gds_validate_string(value_, node, 'footnote')
            self.footnote = value_
            self.footnote_nsprefix_ = child_.prefix
# end class LandPartProperty


class PartNumbers(GeneratedsSuper):
    """PartNumbers -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    ч
    а
    с
    т
    е
    й
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    part_number -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, part_number=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 part_number is None:
            self.part_number = []
        else:
            self.part_number = part_number
        self.part_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PartNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PartNumbers.subclass:
            return PartNumbers.subclass(*args_, **kwargs_)
        else:
            return PartNumbers(*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_part_number(self):
        return self.part_number
    def set_part_number(self, part_number):
        self.part_number = part_number
    def add_part_number(self, value):
        self.part_number.append(value)
    def insert_part_number_at(self, index, value):
        self.part_number.insert(index, value)
    def replace_part_number_at(self, index, value):
        self.part_number[index] = value
    def has__content(self):
        if (
            self.part_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PartNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PartNumbers')
        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_ == 'PartNumbers':
            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_='PartNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PartNumbers', 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_='PartNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PartNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for part_number_ in self.part_number:
            namespaceprefix_ = self.part_number_nsprefix_ + ':' if (UseCapturedNS_ and self.part_number_nsprefix_) else ''
            part_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'part_number':
            obj_ = PartNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.part_number.append(obj_)
            obj_.original_tagname_ = 'part_number'
# end class PartNumbers


class PartNumber(GeneratedsSuper):
    """PartNumber -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    part_number -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, part_number=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.part_number = part_number
        self.part_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PartNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PartNumber.subclass:
            return PartNumber.subclass(*args_, **kwargs_)
        else:
            return PartNumber(*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_part_number(self):
        return self.part_number
    def set_part_number(self, part_number):
        self.part_number = part_number
    def has__content(self):
        if (
            self.part_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PartNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PartNumber')
        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_ == 'PartNumber':
            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_='PartNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PartNumber', 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_='PartNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PartNumber', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.part_number is not None:
            namespaceprefix_ = self.part_number_nsprefix_ + ':' if (UseCapturedNS_ and self.part_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spart_number>%s</%spart_number>%s' % (namespaceprefix_ , self.gds_format_integer(self.part_number, input_name='part_number'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'part_number' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'part_number')
            ival_ = self.gds_validate_integer(ival_, node, 'part_number')
            self.part_number = ival_
            self.part_number_nsprefix_ = child_.prefix
# end class PartNumber


class ObjectPartNumberDate(GeneratedsSuper):
    """ObjectPartNumberDate -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    (
    п
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    д
    а
    т
    а
    )
    part_number -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    entry_date -- Д
    а
    т
    а
    в
    н
    е
    с
    е
    н
    и
    я
    в
    Е
    Г
    Р
    Н
    с
    в
    е
    д
    е
    н
    и
    й
    о
    ч
    а
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, part_number=None, entry_date=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.part_number = part_number
        self.part_number_nsprefix_ = None
        if isinstance(entry_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(entry_date, '%Y-%m-%d').date()
        else:
            initvalue_ = entry_date
        self.entry_date = initvalue_
        self.entry_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectPartNumberDate)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectPartNumberDate.subclass:
            return ObjectPartNumberDate.subclass(*args_, **kwargs_)
        else:
            return ObjectPartNumberDate(*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_part_number(self):
        return self.part_number
    def set_part_number(self, part_number):
        self.part_number = part_number
    def get_entry_date(self):
        return self.entry_date
    def set_entry_date(self, entry_date):
        self.entry_date = entry_date
    def has__content(self):
        if (
            self.part_number is not None or
            self.entry_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectPartNumberDate', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectPartNumberDate')
        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_ == 'ObjectPartNumberDate':
            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_='ObjectPartNumberDate')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectPartNumberDate', 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_='ObjectPartNumberDate'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectPartNumberDate', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.part_number is not None:
            namespaceprefix_ = self.part_number_nsprefix_ + ':' if (UseCapturedNS_ and self.part_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spart_number>%s</%spart_number>%s' % (namespaceprefix_ , self.gds_format_integer(self.part_number, input_name='part_number'), namespaceprefix_ , eol_))
        if self.entry_date is not None:
            namespaceprefix_ = self.entry_date_nsprefix_ + ':' if (UseCapturedNS_ and self.entry_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sentry_date>%s</%sentry_date>%s' % (namespaceprefix_ , self.gds_format_date(self.entry_date, input_name='entry_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'part_number' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'part_number')
            ival_ = self.gds_validate_integer(ival_, node, 'part_number')
            self.part_number = ival_
            self.part_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'entry_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.entry_date = dval_
            self.entry_date_nsprefix_ = child_.prefix
# end class ObjectPartNumberDate


class UnderlyingDocumentsOut(GeneratedsSuper):
    """UnderlyingDocumentsOut -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    (
    в
    с
    е
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    )
    underlying_document -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, underlying_document=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 underlying_document is None:
            self.underlying_document = []
        else:
            self.underlying_document = underlying_document
        self.underlying_document_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, UnderlyingDocumentsOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if UnderlyingDocumentsOut.subclass:
            return UnderlyingDocumentsOut.subclass(*args_, **kwargs_)
        else:
            return UnderlyingDocumentsOut(*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_underlying_document(self):
        return self.underlying_document
    def set_underlying_document(self, underlying_document):
        self.underlying_document = underlying_document
    def add_underlying_document(self, value):
        self.underlying_document.append(value)
    def insert_underlying_document_at(self, index, value):
        self.underlying_document.insert(index, value)
    def replace_underlying_document_at(self, index, value):
        self.underlying_document[index] = value
    def has__content(self):
        if (
            self.underlying_document
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentsOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnderlyingDocumentsOut')
        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_ == 'UnderlyingDocumentsOut':
            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_='UnderlyingDocumentsOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnderlyingDocumentsOut', 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_='UnderlyingDocumentsOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentsOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for underlying_document_ in self.underlying_document:
            namespaceprefix_ = self.underlying_document_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_document_nsprefix_) else ''
            underlying_document_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_document', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'underlying_document':
            obj_ = UnderlyingDocumentOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_document.append(obj_)
            obj_.original_tagname_ = 'underlying_document'
# end class UnderlyingDocumentsOut


class UnderlyingDocumentOut(GeneratedsSuper):
    """UnderlyingDocumentOut -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    (
    в
    с
    е
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    )
    document_code -- К
    о
    д
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    document_series -- С
    е
    р
    и
    я
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_number --
    Н
    о
    м
    е
    р
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_date -- Д
    а
    т
    а
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_issuer -- О
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    ,
    о
    р
    г
    а
    н
    и
    з
    а
    ц
    и
    я
    ,
    в
    ы
    д
    а
    в
    ш
    и
    е
    д
    о
    к
    у
    м
    е
    н
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, document_code=None, document_name=None, document_series=None, document_number=None, document_date=None, document_issuer=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.document_code = document_code
        self.document_code_nsprefix_ = None
        self.document_name = document_name
        self.document_name_nsprefix_ = None
        self.document_series = document_series
        self.document_series_nsprefix_ = None
        self.document_number = document_number
        self.document_number_nsprefix_ = None
        if isinstance(document_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(document_date, '%Y-%m-%d').date()
        else:
            initvalue_ = document_date
        self.document_date = initvalue_
        self.document_date_nsprefix_ = None
        self.document_issuer = document_issuer
        self.validate_MultiLiner(self.document_issuer)
        self.document_issuer_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, UnderlyingDocumentOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if UnderlyingDocumentOut.subclass:
            return UnderlyingDocumentOut.subclass(*args_, **kwargs_)
        else:
            return UnderlyingDocumentOut(*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_document_code(self):
        return self.document_code
    def set_document_code(self, document_code):
        self.document_code = document_code
    def get_document_name(self):
        return self.document_name
    def set_document_name(self, document_name):
        self.document_name = document_name
    def get_document_series(self):
        return self.document_series
    def set_document_series(self, document_series):
        self.document_series = document_series
    def get_document_number(self):
        return self.document_number
    def set_document_number(self, document_number):
        self.document_number = document_number
    def get_document_date(self):
        return self.document_date
    def set_document_date(self, document_date):
        self.document_date = document_date
    def get_document_issuer(self):
        return self.document_issuer
    def set_document_issuer(self, document_issuer):
        self.document_issuer = document_issuer
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.document_code is not None or
            self.document_name is not None or
            self.document_series is not None or
            self.document_number is not None or
            self.document_date is not None or
            self.document_issuer is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnderlyingDocumentOut')
        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_ == 'UnderlyingDocumentOut':
            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_='UnderlyingDocumentOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnderlyingDocumentOut', 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_='UnderlyingDocumentOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.document_code is not None:
            namespaceprefix_ = self.document_code_nsprefix_ + ':' if (UseCapturedNS_ and self.document_code_nsprefix_) else ''
            self.document_code.export(outfile, level, namespaceprefix_, namespacedef_='', name_='document_code', pretty_print=pretty_print)
        if self.document_name is not None:
            namespaceprefix_ = self.document_name_nsprefix_ + ':' if (UseCapturedNS_ and self.document_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_name>%s</%sdocument_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_name), input_name='document_name')), namespaceprefix_ , eol_))
        if self.document_series is not None:
            namespaceprefix_ = self.document_series_nsprefix_ + ':' if (UseCapturedNS_ and self.document_series_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_series>%s</%sdocument_series>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_series), input_name='document_series')), namespaceprefix_ , eol_))
        if self.document_number is not None:
            namespaceprefix_ = self.document_number_nsprefix_ + ':' if (UseCapturedNS_ and self.document_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_number>%s</%sdocument_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_number), input_name='document_number')), namespaceprefix_ , eol_))
        if self.document_date is not None:
            namespaceprefix_ = self.document_date_nsprefix_ + ':' if (UseCapturedNS_ and self.document_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_date>%s</%sdocument_date>%s' % (namespaceprefix_ , self.gds_format_date(self.document_date, input_name='document_date'), namespaceprefix_ , eol_))
        if self.document_issuer is not None:
            namespaceprefix_ = self.document_issuer_nsprefix_ + ':' if (UseCapturedNS_ and self.document_issuer_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_issuer>%s</%sdocument_issuer>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_issuer), input_name='document_issuer')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'document_code':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.document_code = obj_
            obj_.original_tagname_ = 'document_code'
        elif nodeName_ == 'document_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_name')
            value_ = self.gds_validate_string(value_, node, 'document_name')
            self.document_name = value_
            self.document_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_series':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_series')
            value_ = self.gds_validate_string(value_, node, 'document_series')
            self.document_series = value_
            self.document_series_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_number')
            value_ = self.gds_validate_string(value_, node, 'document_number')
            self.document_number = value_
            self.document_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.document_date = dval_
            self.document_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_issuer':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_issuer')
            value_ = self.gds_validate_string(value_, node, 'document_issuer')
            self.document_issuer = value_
            self.document_issuer_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.document_issuer)
# end class UnderlyingDocumentOut


class DocumentsType(GeneratedsSuper):
    """DocumentsType -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    (
    Т
    и
    п
    (
    в
    и
    д
    )
    д
    о
    к
    у
    м
    е
    н
    т
    а
    )
    underlying_document -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, underlying_document=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 underlying_document is None:
            self.underlying_document = []
        else:
            self.underlying_document = underlying_document
        self.underlying_document_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DocumentsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DocumentsType.subclass:
            return DocumentsType.subclass(*args_, **kwargs_)
        else:
            return DocumentsType(*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_underlying_document(self):
        return self.underlying_document
    def set_underlying_document(self, underlying_document):
        self.underlying_document = underlying_document
    def add_underlying_document(self, value):
        self.underlying_document.append(value)
    def insert_underlying_document_at(self, index, value):
        self.underlying_document.insert(index, value)
    def replace_underlying_document_at(self, index, value):
        self.underlying_document[index] = value
    def has__content(self):
        if (
            self.underlying_document
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocumentsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DocumentsType')
        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_ == 'DocumentsType':
            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_='DocumentsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DocumentsType', 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_='DocumentsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocumentsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for underlying_document_ in self.underlying_document:
            namespaceprefix_ = self.underlying_document_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_document_nsprefix_) else ''
            underlying_document_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_document', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'underlying_document':
            obj_ = DocumentType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_document.append(obj_)
            obj_.original_tagname_ = 'underlying_document'
# end class DocumentsType


class DocumentType(GeneratedsSuper):
    """DocumentType -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    (
    т
    и
    п
    ,
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    )
    document_code -- К
    о
    д
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, document_code=None, document_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.document_code = document_code
        self.document_code_nsprefix_ = None
        self.document_name = document_name
        self.document_name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DocumentType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DocumentType.subclass:
            return DocumentType.subclass(*args_, **kwargs_)
        else:
            return DocumentType(*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_document_code(self):
        return self.document_code
    def set_document_code(self, document_code):
        self.document_code = document_code
    def get_document_name(self):
        return self.document_name
    def set_document_name(self, document_name):
        self.document_name = document_name
    def has__content(self):
        if (
            self.document_code is not None or
            self.document_name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocumentType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DocumentType')
        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_ == 'DocumentType':
            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_='DocumentType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DocumentType', 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_='DocumentType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocumentType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.document_code is not None:
            namespaceprefix_ = self.document_code_nsprefix_ + ':' if (UseCapturedNS_ and self.document_code_nsprefix_) else ''
            self.document_code.export(outfile, level, namespaceprefix_, namespacedef_='', name_='document_code', pretty_print=pretty_print)
        if self.document_name is not None:
            namespaceprefix_ = self.document_name_nsprefix_ + ':' if (UseCapturedNS_ and self.document_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_name>%s</%sdocument_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_name), input_name='document_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'document_code':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.document_code = obj_
            obj_.original_tagname_ = 'document_code'
        elif nodeName_ == 'document_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_name')
            value_ = self.gds_validate_string(value_, node, 'document_name')
            self.document_name = value_
            self.document_name_nsprefix_ = child_.prefix
# end class DocumentType


class DocRequisite(GeneratedsSuper):
    """DocRequisite -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    д
    о
    к
    у
    м
    е
    н
    т
    а
    (
    н
    о
    м
    е
    р
    ,
    д
    а
    т
    а
    )
    document_number --
    Н
    о
    м
    е
    р
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_date -- Д
    а
    т
    а
    д
    о
    к
    у
    м
    е
    н
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, document_number=None, document_date=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.document_number = document_number
        self.document_number_nsprefix_ = None
        if isinstance(document_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(document_date, '%Y-%m-%d').date()
        else:
            initvalue_ = document_date
        self.document_date = initvalue_
        self.document_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DocRequisite)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DocRequisite.subclass:
            return DocRequisite.subclass(*args_, **kwargs_)
        else:
            return DocRequisite(*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_document_number(self):
        return self.document_number
    def set_document_number(self, document_number):
        self.document_number = document_number
    def get_document_date(self):
        return self.document_date
    def set_document_date(self, document_date):
        self.document_date = document_date
    def has__content(self):
        if (
            self.document_number is not None or
            self.document_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocRequisite', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DocRequisite')
        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_ == 'DocRequisite':
            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_='DocRequisite')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DocRequisite', 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_='DocRequisite'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocRequisite', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.document_number is not None:
            namespaceprefix_ = self.document_number_nsprefix_ + ':' if (UseCapturedNS_ and self.document_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_number>%s</%sdocument_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_number), input_name='document_number')), namespaceprefix_ , eol_))
        if self.document_date is not None:
            namespaceprefix_ = self.document_date_nsprefix_ + ':' if (UseCapturedNS_ and self.document_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_date>%s</%sdocument_date>%s' % (namespaceprefix_ , self.gds_format_date(self.document_date, input_name='document_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'document_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_number')
            value_ = self.gds_validate_string(value_, node, 'document_number')
            self.document_number = value_
            self.document_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.document_date = dval_
            self.document_date_nsprefix_ = child_.prefix
# end class DocRequisite


class DocRequisiteMain(GeneratedsSuper):
    """DocRequisiteMain -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    д
    о
    к
    у
    м
    е
    н
    т
    а
    (
    о
    с
    н
    о
    в
    н
    ы
    е
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    )
    document_code -- К
    о
    д
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_number --
    Н
    о
    м
    е
    р
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_date -- Д
    а
    т
    а
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_issuer -- О
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    ,
    о
    р
    г
    а
    н
    и
    з
    а
    ц
    и
    я
    ,
    в
    ы
    д
    а
    в
    ш
    и
    е
    д
    о
    к
    у
    м
    е
    н
    т
    .
    А
    в
    т
    о
    р
    д
    о
    к
    у
    м
    е
    н
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, document_code=None, document_number=None, document_date=None, document_issuer=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.document_code = document_code
        self.document_code_nsprefix_ = None
        self.document_number = document_number
        self.document_number_nsprefix_ = None
        if isinstance(document_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(document_date, '%Y-%m-%d').date()
        else:
            initvalue_ = document_date
        self.document_date = initvalue_
        self.document_date_nsprefix_ = None
        self.document_issuer = document_issuer
        self.validate_MultiLiner(self.document_issuer)
        self.document_issuer_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DocRequisiteMain)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DocRequisiteMain.subclass:
            return DocRequisiteMain.subclass(*args_, **kwargs_)
        else:
            return DocRequisiteMain(*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_document_code(self):
        return self.document_code
    def set_document_code(self, document_code):
        self.document_code = document_code
    def get_document_number(self):
        return self.document_number
    def set_document_number(self, document_number):
        self.document_number = document_number
    def get_document_date(self):
        return self.document_date
    def set_document_date(self, document_date):
        self.document_date = document_date
    def get_document_issuer(self):
        return self.document_issuer
    def set_document_issuer(self, document_issuer):
        self.document_issuer = document_issuer
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.document_code is not None or
            self.document_number is not None or
            self.document_date is not None or
            self.document_issuer is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocRequisiteMain', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DocRequisiteMain')
        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_ == 'DocRequisiteMain':
            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_='DocRequisiteMain')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DocRequisiteMain', 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_='DocRequisiteMain'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocRequisiteMain', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.document_code is not None:
            namespaceprefix_ = self.document_code_nsprefix_ + ':' if (UseCapturedNS_ and self.document_code_nsprefix_) else ''
            self.document_code.export(outfile, level, namespaceprefix_, namespacedef_='', name_='document_code', pretty_print=pretty_print)
        if self.document_number is not None:
            namespaceprefix_ = self.document_number_nsprefix_ + ':' if (UseCapturedNS_ and self.document_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_number>%s</%sdocument_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_number), input_name='document_number')), namespaceprefix_ , eol_))
        if self.document_date is not None:
            namespaceprefix_ = self.document_date_nsprefix_ + ':' if (UseCapturedNS_ and self.document_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_date>%s</%sdocument_date>%s' % (namespaceprefix_ , self.gds_format_date(self.document_date, input_name='document_date'), namespaceprefix_ , eol_))
        if self.document_issuer is not None:
            namespaceprefix_ = self.document_issuer_nsprefix_ + ':' if (UseCapturedNS_ and self.document_issuer_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_issuer>%s</%sdocument_issuer>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_issuer), input_name='document_issuer')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'document_code':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.document_code = obj_
            obj_.original_tagname_ = 'document_code'
        elif nodeName_ == 'document_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_number')
            value_ = self.gds_validate_string(value_, node, 'document_number')
            self.document_number = value_
            self.document_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.document_date = dval_
            self.document_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_issuer':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_issuer')
            value_ = self.gds_validate_string(value_, node, 'document_issuer')
            self.document_issuer = value_
            self.document_issuer_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.document_issuer)
# end class DocRequisiteMain


class DocumentRequisiteBase(GeneratedsSuper):
    """DocumentRequisiteBase -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    д
    о
    к
    у
    м
    е
    н
    т
    а
    (
    о
    с
    н
    о
    в
    н
    ы
    е
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    )
    document_code -- К
    о
    д
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    document_series -- С
    е
    р
    и
    я
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_number --
    Н
    о
    м
    е
    р
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_date -- Д
    а
    т
    а
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_issuer -- О
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    ,
    о
    р
    г
    а
    н
    и
    з
    а
    ц
    и
    я
    ,
    в
    ы
    д
    а
    в
    ш
    и
    е
    д
    о
    к
    у
    м
    е
    н
    т
    .
    А
    в
    т
    о
    р
    д
    о
    к
    у
    м
    е
    н
    т
    а
    special_marks -- О
    с
    о
    б
    ы
    е
    о
    т
    м
    е
    т
    к
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, document_code=None, document_name=None, document_series=None, document_number=None, document_date=None, document_issuer=None, special_marks=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.document_code = document_code
        self.document_code_nsprefix_ = None
        self.document_name = document_name
        self.document_name_nsprefix_ = None
        self.document_series = document_series
        self.document_series_nsprefix_ = None
        self.document_number = document_number
        self.document_number_nsprefix_ = None
        if isinstance(document_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(document_date, '%Y-%m-%d').date()
        else:
            initvalue_ = document_date
        self.document_date = initvalue_
        self.document_date_nsprefix_ = None
        self.document_issuer = document_issuer
        self.validate_MultiLiner(self.document_issuer)
        self.document_issuer_nsprefix_ = None
        self.special_marks = special_marks
        self.validate_MultiLiner(self.special_marks)
        self.special_marks_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DocumentRequisiteBase)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DocumentRequisiteBase.subclass:
            return DocumentRequisiteBase.subclass(*args_, **kwargs_)
        else:
            return DocumentRequisiteBase(*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_document_code(self):
        return self.document_code
    def set_document_code(self, document_code):
        self.document_code = document_code
    def get_document_name(self):
        return self.document_name
    def set_document_name(self, document_name):
        self.document_name = document_name
    def get_document_series(self):
        return self.document_series
    def set_document_series(self, document_series):
        self.document_series = document_series
    def get_document_number(self):
        return self.document_number
    def set_document_number(self, document_number):
        self.document_number = document_number
    def get_document_date(self):
        return self.document_date
    def set_document_date(self, document_date):
        self.document_date = document_date
    def get_document_issuer(self):
        return self.document_issuer
    def set_document_issuer(self, document_issuer):
        self.document_issuer = document_issuer
    def get_special_marks(self):
        return self.special_marks
    def set_special_marks(self, special_marks):
        self.special_marks = special_marks
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.document_code is not None or
            self.document_name is not None or
            self.document_series is not None or
            self.document_number is not None or
            self.document_date is not None or
            self.document_issuer is not None or
            self.special_marks is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocumentRequisiteBase', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DocumentRequisiteBase')
        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_ == 'DocumentRequisiteBase':
            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_='DocumentRequisiteBase')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DocumentRequisiteBase', 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_='DocumentRequisiteBase'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocumentRequisiteBase', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.document_code is not None:
            namespaceprefix_ = self.document_code_nsprefix_ + ':' if (UseCapturedNS_ and self.document_code_nsprefix_) else ''
            self.document_code.export(outfile, level, namespaceprefix_, namespacedef_='', name_='document_code', pretty_print=pretty_print)
        if self.document_name is not None:
            namespaceprefix_ = self.document_name_nsprefix_ + ':' if (UseCapturedNS_ and self.document_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_name>%s</%sdocument_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_name), input_name='document_name')), namespaceprefix_ , eol_))
        if self.document_series is not None:
            namespaceprefix_ = self.document_series_nsprefix_ + ':' if (UseCapturedNS_ and self.document_series_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_series>%s</%sdocument_series>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_series), input_name='document_series')), namespaceprefix_ , eol_))
        if self.document_number is not None:
            namespaceprefix_ = self.document_number_nsprefix_ + ':' if (UseCapturedNS_ and self.document_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_number>%s</%sdocument_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_number), input_name='document_number')), namespaceprefix_ , eol_))
        if self.document_date is not None:
            namespaceprefix_ = self.document_date_nsprefix_ + ':' if (UseCapturedNS_ and self.document_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_date>%s</%sdocument_date>%s' % (namespaceprefix_ , self.gds_format_date(self.document_date, input_name='document_date'), namespaceprefix_ , eol_))
        if self.document_issuer is not None:
            namespaceprefix_ = self.document_issuer_nsprefix_ + ':' if (UseCapturedNS_ and self.document_issuer_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_issuer>%s</%sdocument_issuer>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_issuer), input_name='document_issuer')), namespaceprefix_ , eol_))
        if self.special_marks is not None:
            namespaceprefix_ = self.special_marks_nsprefix_ + ':' if (UseCapturedNS_ and self.special_marks_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sspecial_marks>%s</%sspecial_marks>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.special_marks), input_name='special_marks')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'document_code':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.document_code = obj_
            obj_.original_tagname_ = 'document_code'
        elif nodeName_ == 'document_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_name')
            value_ = self.gds_validate_string(value_, node, 'document_name')
            self.document_name = value_
            self.document_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_series':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_series')
            value_ = self.gds_validate_string(value_, node, 'document_series')
            self.document_series = value_
            self.document_series_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_number')
            value_ = self.gds_validate_string(value_, node, 'document_number')
            self.document_number = value_
            self.document_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.document_date = dval_
            self.document_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_issuer':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_issuer')
            value_ = self.gds_validate_string(value_, node, 'document_issuer')
            self.document_issuer = value_
            self.document_issuer_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.document_issuer)
        elif nodeName_ == 'special_marks':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'special_marks')
            value_ = self.gds_validate_string(value_, node, 'special_marks')
            self.special_marks = value_
            self.special_marks_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.special_marks)
# end class DocumentRequisiteBase


class UnderlyingDocumentsOutAll(GeneratedsSuper):
    """UnderlyingDocumentsOutAll -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    (
    в
    с
    е
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    )
    underlying_document -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, underlying_document=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 underlying_document is None:
            self.underlying_document = []
        else:
            self.underlying_document = underlying_document
        self.underlying_document_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, UnderlyingDocumentsOutAll)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if UnderlyingDocumentsOutAll.subclass:
            return UnderlyingDocumentsOutAll.subclass(*args_, **kwargs_)
        else:
            return UnderlyingDocumentsOutAll(*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_underlying_document(self):
        return self.underlying_document
    def set_underlying_document(self, underlying_document):
        self.underlying_document = underlying_document
    def add_underlying_document(self, value):
        self.underlying_document.append(value)
    def insert_underlying_document_at(self, index, value):
        self.underlying_document.insert(index, value)
    def replace_underlying_document_at(self, index, value):
        self.underlying_document[index] = value
    def has__content(self):
        if (
            self.underlying_document
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentsOutAll', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnderlyingDocumentsOutAll')
        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_ == 'UnderlyingDocumentsOutAll':
            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_='UnderlyingDocumentsOutAll')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnderlyingDocumentsOutAll', 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_='UnderlyingDocumentsOutAll'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentsOutAll', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for underlying_document_ in self.underlying_document:
            namespaceprefix_ = self.underlying_document_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_document_nsprefix_) else ''
            underlying_document_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_document', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'underlying_document':
            obj_ = UnderlyingDocumentOutAll.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_document.append(obj_)
            obj_.original_tagname_ = 'underlying_document'
# end class UnderlyingDocumentsOutAll


class UnderlyingDocumentOutAll(GeneratedsSuper):
    """UnderlyingDocumentOutAll -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    (
    в
    с
    е
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    )
    document_code -- К
    о
    д
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    document_series -- С
    е
    р
    и
    я
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_number --
    Н
    о
    м
    е
    р
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_date -- Д
    а
    т
    а
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_issuer -- О
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    ,
    о
    р
    г
    а
    н
    и
    з
    а
    ц
    и
    я
    ,
    в
    ы
    д
    а
    в
    ш
    и
    е
    д
    о
    к
    у
    м
    е
    н
    т
    doc_notarized -- Н
    о
    т
    а
    р
    и
    а
    л
    ь
    н
    о
    е
    у
    д
    о
    с
    т
    о
    в
    е
    р
    е
    н
    и
    е
    д
    о
    к
    у
    м
    е
    н
    т
    а
    fullname_posts_person -- П
    о
    л
    н
    о
    е
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    д
    о
    л
    ж
    н
    о
    с
    т
    и
    д
    о
    л
    ж
    н
    о
    с
    т
    н
    о
    г
    о
    л
    и
    ц
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, document_code=None, document_name=None, document_series=None, document_number=None, document_date=None, document_issuer=None, doc_notarized=None, fullname_posts_person=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.document_code = document_code
        self.document_code_nsprefix_ = None
        self.document_name = document_name
        self.document_name_nsprefix_ = None
        self.document_series = document_series
        self.document_series_nsprefix_ = None
        self.document_number = document_number
        self.document_number_nsprefix_ = None
        if isinstance(document_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(document_date, '%Y-%m-%d').date()
        else:
            initvalue_ = document_date
        self.document_date = initvalue_
        self.document_date_nsprefix_ = None
        self.document_issuer = document_issuer
        self.validate_MultiLiner(self.document_issuer)
        self.document_issuer_nsprefix_ = None
        self.doc_notarized = doc_notarized
        self.doc_notarized_nsprefix_ = None
        self.fullname_posts_person = fullname_posts_person
        self.fullname_posts_person_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, UnderlyingDocumentOutAll)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if UnderlyingDocumentOutAll.subclass:
            return UnderlyingDocumentOutAll.subclass(*args_, **kwargs_)
        else:
            return UnderlyingDocumentOutAll(*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_document_code(self):
        return self.document_code
    def set_document_code(self, document_code):
        self.document_code = document_code
    def get_document_name(self):
        return self.document_name
    def set_document_name(self, document_name):
        self.document_name = document_name
    def get_document_series(self):
        return self.document_series
    def set_document_series(self, document_series):
        self.document_series = document_series
    def get_document_number(self):
        return self.document_number
    def set_document_number(self, document_number):
        self.document_number = document_number
    def get_document_date(self):
        return self.document_date
    def set_document_date(self, document_date):
        self.document_date = document_date
    def get_document_issuer(self):
        return self.document_issuer
    def set_document_issuer(self, document_issuer):
        self.document_issuer = document_issuer
    def get_doc_notarized(self):
        return self.doc_notarized
    def set_doc_notarized(self, doc_notarized):
        self.doc_notarized = doc_notarized
    def get_fullname_posts_person(self):
        return self.fullname_posts_person
    def set_fullname_posts_person(self, fullname_posts_person):
        self.fullname_posts_person = fullname_posts_person
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.document_code is not None or
            self.document_name is not None or
            self.document_series is not None or
            self.document_number is not None or
            self.document_date is not None or
            self.document_issuer is not None or
            self.doc_notarized is not None or
            self.fullname_posts_person is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentOutAll', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnderlyingDocumentOutAll')
        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_ == 'UnderlyingDocumentOutAll':
            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_='UnderlyingDocumentOutAll')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnderlyingDocumentOutAll', 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_='UnderlyingDocumentOutAll'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentOutAll', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.document_code is not None:
            namespaceprefix_ = self.document_code_nsprefix_ + ':' if (UseCapturedNS_ and self.document_code_nsprefix_) else ''
            self.document_code.export(outfile, level, namespaceprefix_, namespacedef_='', name_='document_code', pretty_print=pretty_print)
        if self.document_name is not None:
            namespaceprefix_ = self.document_name_nsprefix_ + ':' if (UseCapturedNS_ and self.document_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_name>%s</%sdocument_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_name), input_name='document_name')), namespaceprefix_ , eol_))
        if self.document_series is not None:
            namespaceprefix_ = self.document_series_nsprefix_ + ':' if (UseCapturedNS_ and self.document_series_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_series>%s</%sdocument_series>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_series), input_name='document_series')), namespaceprefix_ , eol_))
        if self.document_number is not None:
            namespaceprefix_ = self.document_number_nsprefix_ + ':' if (UseCapturedNS_ and self.document_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_number>%s</%sdocument_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_number), input_name='document_number')), namespaceprefix_ , eol_))
        if self.document_date is not None:
            namespaceprefix_ = self.document_date_nsprefix_ + ':' if (UseCapturedNS_ and self.document_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_date>%s</%sdocument_date>%s' % (namespaceprefix_ , self.gds_format_date(self.document_date, input_name='document_date'), namespaceprefix_ , eol_))
        if self.document_issuer is not None:
            namespaceprefix_ = self.document_issuer_nsprefix_ + ':' if (UseCapturedNS_ and self.document_issuer_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_issuer>%s</%sdocument_issuer>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_issuer), input_name='document_issuer')), namespaceprefix_ , eol_))
        if self.doc_notarized is not None:
            namespaceprefix_ = self.doc_notarized_nsprefix_ + ':' if (UseCapturedNS_ and self.doc_notarized_nsprefix_) else ''
            self.doc_notarized.export(outfile, level, namespaceprefix_, namespacedef_='', name_='doc_notarized', pretty_print=pretty_print)
        if self.fullname_posts_person is not None:
            namespaceprefix_ = self.fullname_posts_person_nsprefix_ + ':' if (UseCapturedNS_ and self.fullname_posts_person_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfullname_posts_person>%s</%sfullname_posts_person>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.fullname_posts_person), input_name='fullname_posts_person')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'document_code':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.document_code = obj_
            obj_.original_tagname_ = 'document_code'
        elif nodeName_ == 'document_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_name')
            value_ = self.gds_validate_string(value_, node, 'document_name')
            self.document_name = value_
            self.document_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_series':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_series')
            value_ = self.gds_validate_string(value_, node, 'document_series')
            self.document_series = value_
            self.document_series_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_number')
            value_ = self.gds_validate_string(value_, node, 'document_number')
            self.document_number = value_
            self.document_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.document_date = dval_
            self.document_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_issuer':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_issuer')
            value_ = self.gds_validate_string(value_, node, 'document_issuer')
            self.document_issuer = value_
            self.document_issuer_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.document_issuer)
        elif nodeName_ == 'doc_notarized':
            obj_ = DocNotarized.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.doc_notarized = obj_
            obj_.original_tagname_ = 'doc_notarized'
        elif nodeName_ == 'fullname_posts_person':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'fullname_posts_person')
            value_ = self.gds_validate_string(value_, node, 'fullname_posts_person')
            self.fullname_posts_person = value_
            self.fullname_posts_person_nsprefix_ = child_.prefix
# end class UnderlyingDocumentOutAll


class BasisHiredHouse(GeneratedsSuper):
    """BasisHiredHouse -- О
    с
    н
    о
    в
    а
    н
    и
    е
    с
    о
    з
    д
    а
    н
    и
    я
    н
    а
    е
    м
    н
    о
    г
    о
    д
    о
    м
    а
    act -- А
    к
    т
    о
    п
    р
    е
    д
    о
    с
    т
    а
    в
    л
    е
    н
    и
    и
    contract -- Д
    о
    г
    о
    в
    о
    р
    decision_owner -- Р
    е
    ш
    е
    н
    и
    е
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    а
    contract_owner -- Д
    о
    г
    о
    в
    о
    р
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, act=None, contract=None, decision_owner=None, contract_owner=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.act = act
        self.act_nsprefix_ = None
        self.contract = contract
        self.contract_nsprefix_ = None
        self.decision_owner = decision_owner
        self.decision_owner_nsprefix_ = None
        self.contract_owner = contract_owner
        self.contract_owner_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BasisHiredHouse)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BasisHiredHouse.subclass:
            return BasisHiredHouse.subclass(*args_, **kwargs_)
        else:
            return BasisHiredHouse(*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_act(self):
        return self.act
    def set_act(self, act):
        self.act = act
    def get_contract(self):
        return self.contract
    def set_contract(self, contract):
        self.contract = contract
    def get_decision_owner(self):
        return self.decision_owner
    def set_decision_owner(self, decision_owner):
        self.decision_owner = decision_owner
    def get_contract_owner(self):
        return self.contract_owner
    def set_contract_owner(self, contract_owner):
        self.contract_owner = contract_owner
    def has__content(self):
        if (
            self.act is not None or
            self.contract is not None or
            self.decision_owner is not None or
            self.contract_owner is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BasisHiredHouse', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BasisHiredHouse')
        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_ == 'BasisHiredHouse':
            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_='BasisHiredHouse')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BasisHiredHouse', 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_='BasisHiredHouse'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BasisHiredHouse', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.act is not None:
            namespaceprefix_ = self.act_nsprefix_ + ':' if (UseCapturedNS_ and self.act_nsprefix_) else ''
            self.act.export(outfile, level, namespaceprefix_, namespacedef_='', name_='act', pretty_print=pretty_print)
        if self.contract is not None:
            namespaceprefix_ = self.contract_nsprefix_ + ':' if (UseCapturedNS_ and self.contract_nsprefix_) else ''
            self.contract.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contract', pretty_print=pretty_print)
        if self.decision_owner is not None:
            namespaceprefix_ = self.decision_owner_nsprefix_ + ':' if (UseCapturedNS_ and self.decision_owner_nsprefix_) else ''
            self.decision_owner.export(outfile, level, namespaceprefix_, namespacedef_='', name_='decision_owner', pretty_print=pretty_print)
        if self.contract_owner is not None:
            namespaceprefix_ = self.contract_owner_nsprefix_ + ':' if (UseCapturedNS_ and self.contract_owner_nsprefix_) else ''
            self.contract_owner.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contract_owner', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'act':
            obj_ = actType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.act = obj_
            obj_.original_tagname_ = 'act'
        elif nodeName_ == 'contract':
            obj_ = Contract.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contract = obj_
            obj_.original_tagname_ = 'contract'
        elif nodeName_ == 'decision_owner':
            obj_ = decision_ownerType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.decision_owner = obj_
            obj_.original_tagname_ = 'decision_owner'
        elif nodeName_ == 'contract_owner':
            obj_ = Contract.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contract_owner = obj_
            obj_.original_tagname_ = 'contract_owner'
# end class BasisHiredHouse


class Contract(GeneratedsSuper):
    """Contract -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    и
    с
    т
    о
    р
    о
    н
    ы
    д
    о
    г
    о
    в
    о
    р
    а
    underlying_doc -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    contractors -- С
    т
    о
    р
    о
    н
    ы
    д
    о
    г
    о
    в
    о
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, underlying_doc=None, contractors=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.underlying_doc = underlying_doc
        self.underlying_doc_nsprefix_ = None
        self.contractors = contractors
        self.contractors_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Contract)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Contract.subclass:
            return Contract.subclass(*args_, **kwargs_)
        else:
            return Contract(*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_underlying_doc(self):
        return self.underlying_doc
    def set_underlying_doc(self, underlying_doc):
        self.underlying_doc = underlying_doc
    def get_contractors(self):
        return self.contractors
    def set_contractors(self, contractors):
        self.contractors = contractors
    def has__content(self):
        if (
            self.underlying_doc is not None or
            self.contractors is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Contract', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Contract')
        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_ == 'Contract':
            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_='Contract')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Contract', 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_='Contract'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Contract', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.underlying_doc is not None:
            namespaceprefix_ = self.underlying_doc_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_doc_nsprefix_) else ''
            self.underlying_doc.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_doc', pretty_print=pretty_print)
        if self.contractors is not None:
            namespaceprefix_ = self.contractors_nsprefix_ + ':' if (UseCapturedNS_ and self.contractors_nsprefix_) else ''
            self.contractors.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contractors', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'underlying_doc':
            obj_ = DocRequisiteMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_doc = obj_
            obj_.original_tagname_ = 'underlying_doc'
        elif nodeName_ == 'contractors':
            obj_ = Contractors.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contractors = obj_
            obj_.original_tagname_ = 'contractors'
# end class Contract


class CourtDecisionOut(GeneratedsSuper):
    """CourtDecisionOut -- Р
    е
    ш
    е
    н
    и
    е
    с
    у
    д
    а
    court_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    с
    у
    д
    а
    decision_requisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    в
    с
    т
    у
    п
    и
    в
    ш
    е
    г
    о
    в
    з
    а
    к
    о
    н
    н
    у
    ю
    с
    и
    л
    у
    р
    е
    ш
    е
    н
    и
    я
    с
    у
    д
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, court_name=None, decision_requisites=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.court_name = court_name
        self.court_name_nsprefix_ = None
        self.decision_requisites = decision_requisites
        self.decision_requisites_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CourtDecisionOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CourtDecisionOut.subclass:
            return CourtDecisionOut.subclass(*args_, **kwargs_)
        else:
            return CourtDecisionOut(*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_court_name(self):
        return self.court_name
    def set_court_name(self, court_name):
        self.court_name = court_name
    def get_decision_requisites(self):
        return self.decision_requisites
    def set_decision_requisites(self, decision_requisites):
        self.decision_requisites = decision_requisites
    def has__content(self):
        if (
            self.court_name is not None or
            self.decision_requisites is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CourtDecisionOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CourtDecisionOut')
        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_ == 'CourtDecisionOut':
            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_='CourtDecisionOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CourtDecisionOut', 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_='CourtDecisionOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CourtDecisionOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.court_name is not None:
            namespaceprefix_ = self.court_name_nsprefix_ + ':' if (UseCapturedNS_ and self.court_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scourt_name>%s</%scourt_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.court_name), input_name='court_name')), namespaceprefix_ , eol_))
        if self.decision_requisites is not None:
            namespaceprefix_ = self.decision_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.decision_requisites_nsprefix_) else ''
            self.decision_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='decision_requisites', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'court_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'court_name')
            value_ = self.gds_validate_string(value_, node, 'court_name')
            self.court_name = value_
            self.court_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'decision_requisites':
            obj_ = DecisionRequisites.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.decision_requisites = obj_
            obj_.original_tagname_ = 'decision_requisites'
# end class CourtDecisionOut


class DecisionRequisites(GeneratedsSuper):
    """DecisionRequisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    в
    с
    т
    у
    п
    и
    в
    ш
    е
    г
    о
    в
    з
    а
    к
    о
    н
    н
    у
    ю
    с
    и
    л
    у
    р
    е
    ш
    е
    н
    и
    я
    с
    у
    д
    а
    document_date -- Д
    а
    т
    а
    в
    ы
    н
    е
    с
    е
    н
    и
    я
    р
    е
    ш
    е
    н
    и
    я
    document_number --
    Н
    о
    м
    е
    р
    р
    е
    ш
    е
    н
    и
    я
    (
    д
    е
    л
    а
    )
    date_entry_into_force -- Д
    а
    т
    а
    в
    с
    т
    у
    п
    л
    е
    н
    и
    я
    в
    з
    а
    к
    о
    н
    н
    у
    ю
    с
    и
    л
    у
    р
    е
    ш
    е
    н
    и
    я
    с
    у
    д
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, document_date=None, document_number=None, date_entry_into_force=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(document_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(document_date, '%Y-%m-%d').date()
        else:
            initvalue_ = document_date
        self.document_date = initvalue_
        self.document_date_nsprefix_ = None
        self.document_number = document_number
        self.document_number_nsprefix_ = None
        if isinstance(date_entry_into_force, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_entry_into_force, '%Y-%m-%d').date()
        else:
            initvalue_ = date_entry_into_force
        self.date_entry_into_force = initvalue_
        self.date_entry_into_force_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DecisionRequisites)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DecisionRequisites.subclass:
            return DecisionRequisites.subclass(*args_, **kwargs_)
        else:
            return DecisionRequisites(*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_document_date(self):
        return self.document_date
    def set_document_date(self, document_date):
        self.document_date = document_date
    def get_document_number(self):
        return self.document_number
    def set_document_number(self, document_number):
        self.document_number = document_number
    def get_date_entry_into_force(self):
        return self.date_entry_into_force
    def set_date_entry_into_force(self, date_entry_into_force):
        self.date_entry_into_force = date_entry_into_force
    def has__content(self):
        if (
            self.document_date is not None or
            self.document_number is not None or
            self.date_entry_into_force is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DecisionRequisites', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DecisionRequisites')
        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_ == 'DecisionRequisites':
            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_='DecisionRequisites')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DecisionRequisites', 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_='DecisionRequisites'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DecisionRequisites', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.document_date is not None:
            namespaceprefix_ = self.document_date_nsprefix_ + ':' if (UseCapturedNS_ and self.document_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_date>%s</%sdocument_date>%s' % (namespaceprefix_ , self.gds_format_date(self.document_date, input_name='document_date'), namespaceprefix_ , eol_))
        if self.document_number is not None:
            namespaceprefix_ = self.document_number_nsprefix_ + ':' if (UseCapturedNS_ and self.document_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_number>%s</%sdocument_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_number), input_name='document_number')), namespaceprefix_ , eol_))
        if self.date_entry_into_force is not None:
            namespaceprefix_ = self.date_entry_into_force_nsprefix_ + ':' if (UseCapturedNS_ and self.date_entry_into_force_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_entry_into_force>%s</%sdate_entry_into_force>%s' % (namespaceprefix_ , self.gds_format_date(self.date_entry_into_force, input_name='date_entry_into_force'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'document_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.document_date = dval_
            self.document_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_number')
            value_ = self.gds_validate_string(value_, node, 'document_number')
            self.document_number = value_
            self.document_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'date_entry_into_force':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_entry_into_force = dval_
            self.date_entry_into_force_nsprefix_ = child_.prefix
# end class DecisionRequisites


class InformationFund(GeneratedsSuper):
    """InformationFund -- И
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    о
    п
    е
    р
    е
    д
    а
    ч
    е
    к
    а
    р
    т
    ы
    (
    п
    л
    а
    н
    а
    )
    о
    б
    ъ
    е
    к
    т
    а
    з
    е
    м
    л
    е
    у
    с
    т
    р
    о
    й
    с
    т
    в
    а
    в
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    й
    ф
    о
    н
    д
    д
    а
    н
    н
    ы
    х
    ,
    п
    о
    л
    у
    ч
    е
    н
    н
    ы
    х
    в
    р
    е
    з
    у
    л
    ь
    т
    а
    т
    е
    п
    р
    о
    в
    е
    д
    е
    н
    и
    я
    з
    е
    м
    л
    е
    у
    с
    т
    р
    о
    й
    с
    т
    в
    а
    number_reg -- Р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    о
    н
    н
    ы
    й
    н
    о
    м
    е
    р
    date_reg -- Д
    а
    т
    а
    п
    е
    р
    е
    д
    а
    ч
    и
    name_archive -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    р
    г
    а
    н
    а
    (
    о
    р
    г
    а
    н
    и
    з
    а
    ц
    и
    и
    ),
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    я
    ю
    щ
    е
    г
    о
    х
    р
    а
    н
    е
    н
    и
    е
    з
    е
    м
    л
    е
    у
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    н
    о
    й
    д
    о
    к
    у
    м
    е
    н
    т
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_reg=None, date_reg=None, name_archive=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.number_reg = number_reg
        self.validate_number_regType(self.number_reg)
        self.number_reg_nsprefix_ = None
        if isinstance(date_reg, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_reg, '%Y-%m-%d').date()
        else:
            initvalue_ = date_reg
        self.date_reg = initvalue_
        self.date_reg_nsprefix_ = None
        self.name_archive = name_archive
        self.name_archive_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, InformationFund)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if InformationFund.subclass:
            return InformationFund.subclass(*args_, **kwargs_)
        else:
            return InformationFund(*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_reg(self):
        return self.number_reg
    def set_number_reg(self, number_reg):
        self.number_reg = number_reg
    def get_date_reg(self):
        return self.date_reg
    def set_date_reg(self, date_reg):
        self.date_reg = date_reg
    def get_name_archive(self):
        return self.name_archive
    def set_name_archive(self, name_archive):
        self.name_archive = name_archive
    def validate_number_regType(self, value):
        result = True
        # Validate type number_regType, 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
            if len(value) > 50:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxLength restriction on number_regType' % {"value" : encode_str_2_3(value), "lineno": lineno} )
                result = False
            if len(value) < 1:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minLength restriction on number_regType' % {"value" : encode_str_2_3(value), "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.number_reg is not None or
            self.date_reg is not None or
            self.name_archive is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='InformationFund', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('InformationFund')
        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_ == 'InformationFund':
            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_='InformationFund')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='InformationFund', 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_='InformationFund'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='InformationFund', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_reg is not None:
            namespaceprefix_ = self.number_reg_nsprefix_ + ':' if (UseCapturedNS_ and self.number_reg_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_reg>%s</%snumber_reg>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number_reg), input_name='number_reg')), namespaceprefix_ , eol_))
        if self.date_reg is not None:
            namespaceprefix_ = self.date_reg_nsprefix_ + ':' if (UseCapturedNS_ and self.date_reg_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_reg>%s</%sdate_reg>%s' % (namespaceprefix_ , self.gds_format_date(self.date_reg, input_name='date_reg'), namespaceprefix_ , eol_))
        if self.name_archive is not None:
            namespaceprefix_ = self.name_archive_nsprefix_ + ':' if (UseCapturedNS_ and self.name_archive_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_archive>%s</%sname_archive>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_archive), input_name='name_archive')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_reg':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'number_reg')
            value_ = self.gds_validate_string(value_, node, 'number_reg')
            self.number_reg = value_
            self.number_reg_nsprefix_ = child_.prefix
            # validate type number_regType
            self.validate_number_regType(self.number_reg)
        elif nodeName_ == 'date_reg':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_reg = dval_
            self.date_reg_nsprefix_ = child_.prefix
        elif nodeName_ == 'name_archive':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_archive')
            value_ = self.gds_validate_string(value_, node, 'name_archive')
            self.name_archive = value_
            self.name_archive_nsprefix_ = child_.prefix
# end class InformationFund


class UnderlyingDocumentsMain(GeneratedsSuper):
    """UnderlyingDocumentsMain -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    (
    о
    с
    н
    о
    в
    н
    ы
    е
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    )
    underlying_document -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    (
    о
    с
    н
    о
    в
    н
    ы
    е
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, underlying_document=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 underlying_document is None:
            self.underlying_document = []
        else:
            self.underlying_document = underlying_document
        self.underlying_document_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, UnderlyingDocumentsMain)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if UnderlyingDocumentsMain.subclass:
            return UnderlyingDocumentsMain.subclass(*args_, **kwargs_)
        else:
            return UnderlyingDocumentsMain(*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_underlying_document(self):
        return self.underlying_document
    def set_underlying_document(self, underlying_document):
        self.underlying_document = underlying_document
    def add_underlying_document(self, value):
        self.underlying_document.append(value)
    def insert_underlying_document_at(self, index, value):
        self.underlying_document.insert(index, value)
    def replace_underlying_document_at(self, index, value):
        self.underlying_document[index] = value
    def has__content(self):
        if (
            self.underlying_document
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentsMain', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnderlyingDocumentsMain')
        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_ == 'UnderlyingDocumentsMain':
            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_='UnderlyingDocumentsMain')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnderlyingDocumentsMain', 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_='UnderlyingDocumentsMain'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentsMain', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for underlying_document_ in self.underlying_document:
            namespaceprefix_ = self.underlying_document_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_document_nsprefix_) else ''
            underlying_document_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_document', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'underlying_document':
            obj_ = DocRequisiteMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_document.append(obj_)
            obj_.original_tagname_ = 'underlying_document'
# end class UnderlyingDocumentsMain


class NaturalObjects(GeneratedsSuper):
    """NaturalObjects -- П
    р
    и
    р
    о
    д
    н
    ы
    е
    о
    б
    ъ
    е
    к
    т
    ы
    forests -- Л
    е
    с
    н
    ы
    е
    о
    б
    ъ
    е
    к
    т
    ы
    waters -- В
    о
    д
    н
    ы
    е
    о
    б
    ъ
    е
    к
    т
    ы
    other_natural_objects -- И
    н
    ы
    е
    п
    р
    и
    р
    о
    д
    н
    ы
    е
    о
    б
    ъ
    е
    к
    т
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, forests=None, waters=None, other_natural_objects=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.forests = forests
        self.forests_nsprefix_ = None
        self.waters = waters
        self.waters_nsprefix_ = None
        self.other_natural_objects = other_natural_objects
        self.other_natural_objects_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, NaturalObjects)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if NaturalObjects.subclass:
            return NaturalObjects.subclass(*args_, **kwargs_)
        else:
            return NaturalObjects(*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_forests(self):
        return self.forests
    def set_forests(self, forests):
        self.forests = forests
    def get_waters(self):
        return self.waters
    def set_waters(self, waters):
        self.waters = waters
    def get_other_natural_objects(self):
        return self.other_natural_objects
    def set_other_natural_objects(self, other_natural_objects):
        self.other_natural_objects = other_natural_objects
    def has__content(self):
        if (
            self.forests is not None or
            self.waters is not None or
            self.other_natural_objects is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NaturalObjects', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('NaturalObjects')
        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_ == 'NaturalObjects':
            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_='NaturalObjects')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NaturalObjects', 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_='NaturalObjects'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NaturalObjects', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.forests is not None:
            namespaceprefix_ = self.forests_nsprefix_ + ':' if (UseCapturedNS_ and self.forests_nsprefix_) else ''
            self.forests.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forests', pretty_print=pretty_print)
        if self.waters is not None:
            namespaceprefix_ = self.waters_nsprefix_ + ':' if (UseCapturedNS_ and self.waters_nsprefix_) else ''
            self.waters.export(outfile, level, namespaceprefix_, namespacedef_='', name_='waters', pretty_print=pretty_print)
        if self.other_natural_objects is not None:
            namespaceprefix_ = self.other_natural_objects_nsprefix_ + ':' if (UseCapturedNS_ and self.other_natural_objects_nsprefix_) else ''
            self.other_natural_objects.export(outfile, level, namespaceprefix_, namespacedef_='', name_='other_natural_objects', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'forests':
            obj_ = Forests.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forests = obj_
            obj_.original_tagname_ = 'forests'
        elif nodeName_ == 'waters':
            obj_ = Waters.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.waters = obj_
            obj_.original_tagname_ = 'waters'
        elif nodeName_ == 'other_natural_objects':
            obj_ = OtherNaturalObjects.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.other_natural_objects = obj_
            obj_.original_tagname_ = 'other_natural_objects'
# end class NaturalObjects


class OtherNaturalObjects(GeneratedsSuper):
    """OtherNaturalObjects -- И
    н
    ы
    е
    п
    р
    и
    р
    о
    д
    н
    ы
    е
    о
    б
    ъ
    е
    к
    т
    ы
    other_natural_object -- И
    н
    о
    й
    п
    р
    и
    р
    о
    д
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, other_natural_object=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 other_natural_object is None:
            self.other_natural_object = []
        else:
            self.other_natural_object = other_natural_object
        self.other_natural_object_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OtherNaturalObjects)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OtherNaturalObjects.subclass:
            return OtherNaturalObjects.subclass(*args_, **kwargs_)
        else:
            return OtherNaturalObjects(*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_other_natural_object(self):
        return self.other_natural_object
    def set_other_natural_object(self, other_natural_object):
        self.other_natural_object = other_natural_object
    def add_other_natural_object(self, value):
        self.other_natural_object.append(value)
    def insert_other_natural_object_at(self, index, value):
        self.other_natural_object.insert(index, value)
    def replace_other_natural_object_at(self, index, value):
        self.other_natural_object[index] = value
    def has__content(self):
        if (
            self.other_natural_object
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OtherNaturalObjects', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OtherNaturalObjects')
        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_ == 'OtherNaturalObjects':
            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_='OtherNaturalObjects')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OtherNaturalObjects', 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_='OtherNaturalObjects'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OtherNaturalObjects', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for other_natural_object_ in self.other_natural_object:
            namespaceprefix_ = self.other_natural_object_nsprefix_ + ':' if (UseCapturedNS_ and self.other_natural_object_nsprefix_) else ''
            other_natural_object_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='other_natural_object', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'other_natural_object':
            obj_ = OtherNaturalObject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.other_natural_object.append(obj_)
            obj_.original_tagname_ = 'other_natural_object'
# end class OtherNaturalObjects


class OtherNaturalObject(GeneratedsSuper):
    """OtherNaturalObject -- И
    н
    о
    й
    п
    р
    и
    р
    о
    д
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    other_object_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    other_object_purpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, other_object_name=None, other_object_purpose=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.other_object_name = other_object_name
        self.other_object_name_nsprefix_ = None
        self.other_object_purpose = other_object_purpose
        self.other_object_purpose_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OtherNaturalObject)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OtherNaturalObject.subclass:
            return OtherNaturalObject.subclass(*args_, **kwargs_)
        else:
            return OtherNaturalObject(*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_other_object_name(self):
        return self.other_object_name
    def set_other_object_name(self, other_object_name):
        self.other_object_name = other_object_name
    def get_other_object_purpose(self):
        return self.other_object_purpose
    def set_other_object_purpose(self, other_object_purpose):
        self.other_object_purpose = other_object_purpose
    def has__content(self):
        if (
            self.other_object_name is not None or
            self.other_object_purpose is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OtherNaturalObject', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OtherNaturalObject')
        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_ == 'OtherNaturalObject':
            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_='OtherNaturalObject')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OtherNaturalObject', 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_='OtherNaturalObject'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OtherNaturalObject', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.other_object_name is not None:
            namespaceprefix_ = self.other_object_name_nsprefix_ + ':' if (UseCapturedNS_ and self.other_object_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sother_object_name>%s</%sother_object_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.other_object_name), input_name='other_object_name')), namespaceprefix_ , eol_))
        if self.other_object_purpose is not None:
            namespaceprefix_ = self.other_object_purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.other_object_purpose_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sother_object_purpose>%s</%sother_object_purpose>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.other_object_purpose), input_name='other_object_purpose')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'other_object_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'other_object_name')
            value_ = self.gds_validate_string(value_, node, 'other_object_name')
            self.other_object_name = value_
            self.other_object_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'other_object_purpose':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'other_object_purpose')
            value_ = self.gds_validate_string(value_, node, 'other_object_purpose')
            self.other_object_purpose = value_
            self.other_object_purpose_nsprefix_ = child_.prefix
# end class OtherNaturalObject


class Forests(GeneratedsSuper):
    """Forests -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    а
    л
    е
    с
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    forest -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    а
    л
    е
    с
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, forest=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 forest is None:
            self.forest = []
        else:
            self.forest = forest
        self.forest_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Forests)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Forests.subclass:
            return Forests.subclass(*args_, **kwargs_)
        else:
            return Forests(*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_forest(self):
        return self.forest
    def set_forest(self, forest):
        self.forest = forest
    def add_forest(self, value):
        self.forest.append(value)
    def insert_forest_at(self, index, value):
        self.forest.insert(index, value)
    def replace_forest_at(self, index, value):
        self.forest[index] = value
    def has__content(self):
        if (
            self.forest
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Forests', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Forests')
        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_ == 'Forests':
            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_='Forests')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Forests', 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_='Forests'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Forests', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for forest_ in self.forest:
            namespaceprefix_ = self.forest_nsprefix_ + ':' if (UseCapturedNS_ and self.forest_nsprefix_) else ''
            forest_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forest', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'forest':
            obj_ = forestType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forest.append(obj_)
            obj_.original_tagname_ = 'forest'
# end class Forests


class Forest(GeneratedsSuper):
    """Forest -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    а
    л
    е
    с
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    forestry -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    а
    ,
    л
    е
    с
    о
    п
    а
    р
    к
    а
    ,
    у
    ч
    а
    с
    т
    к
    о
    в
    о
    г
    о
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    а
    forest_quarters -- Н
    о
    м
    е
    р
    а
    л
    е
    с
    н
    ы
    х
    к
    в
    а
    р
    т
    а
    л
    о
    в
    forest_purpose -- Ц
    е
    л
    е
    в
    о
    е
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    (
    к
    а
    т
    е
    г
    о
    р
    и
    я
    )
    л
    е
    с
    о
    в
    forest_category -- К
    а
    т
    е
    г
    о
    р
    и
    я
    з
    а
    щ
    и
    т
    н
    ы
    х
    л
    е
    с
    о
    в
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, forestry=None, forest_quarters=None, forest_purpose=None, forest_category=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.forestry = forestry
        self.forestry_nsprefix_ = None
        self.forest_quarters = forest_quarters
        self.forest_quarters_nsprefix_ = None
        self.forest_purpose = forest_purpose
        self.forest_purpose_nsprefix_ = None
        self.forest_category = forest_category
        self.forest_category_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Forest)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Forest.subclass:
            return Forest.subclass(*args_, **kwargs_)
        else:
            return Forest(*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_forestry(self):
        return self.forestry
    def set_forestry(self, forestry):
        self.forestry = forestry
    def get_forest_quarters(self):
        return self.forest_quarters
    def set_forest_quarters(self, forest_quarters):
        self.forest_quarters = forest_quarters
    def get_forest_purpose(self):
        return self.forest_purpose
    def set_forest_purpose(self, forest_purpose):
        self.forest_purpose = forest_purpose
    def get_forest_category(self):
        return self.forest_category
    def set_forest_category(self, forest_category):
        self.forest_category = forest_category
    def has__content(self):
        if (
            self.forestry is not None or
            self.forest_quarters is not None or
            self.forest_purpose is not None or
            self.forest_category is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Forest', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Forest')
        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_ == 'Forest':
            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_='Forest')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Forest', 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_='Forest'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Forest', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.forestry is not None:
            namespaceprefix_ = self.forestry_nsprefix_ + ':' if (UseCapturedNS_ and self.forestry_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sforestry>%s</%sforestry>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.forestry), input_name='forestry')), namespaceprefix_ , eol_))
        if self.forest_quarters is not None:
            namespaceprefix_ = self.forest_quarters_nsprefix_ + ':' if (UseCapturedNS_ and self.forest_quarters_nsprefix_) else ''
            self.forest_quarters.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forest_quarters', pretty_print=pretty_print)
        if self.forest_purpose is not None:
            namespaceprefix_ = self.forest_purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.forest_purpose_nsprefix_) else ''
            self.forest_purpose.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forest_purpose', pretty_print=pretty_print)
        if self.forest_category is not None:
            namespaceprefix_ = self.forest_category_nsprefix_ + ':' if (UseCapturedNS_ and self.forest_category_nsprefix_) else ''
            self.forest_category.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forest_category', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'forestry':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'forestry')
            value_ = self.gds_validate_string(value_, node, 'forestry')
            self.forestry = value_
            self.forestry_nsprefix_ = child_.prefix
        elif nodeName_ == 'forest_quarters':
            obj_ = forest_quartersType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forest_quarters = obj_
            obj_.original_tagname_ = 'forest_quarters'
        elif nodeName_ == 'forest_purpose':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forest_purpose = obj_
            obj_.original_tagname_ = 'forest_purpose'
        elif nodeName_ == 'forest_category':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forest_category = obj_
            obj_.original_tagname_ = 'forest_category'
# end class Forest


class ForestQuarters(GeneratedsSuper):
    """ForestQuarters -- Н
    о
    м
    е
    р
    а
    л
    е
    с
    н
    ы
    х
    к
    в
    а
    р
    т
    а
    л
    о
    в
    forest_quarter -- Н
    о
    м
    е
    р
    л
    е
    с
    н
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, forest_quarter=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 forest_quarter is None:
            self.forest_quarter = []
        else:
            self.forest_quarter = forest_quarter
        self.forest_quarter_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ForestQuarters)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ForestQuarters.subclass:
            return ForestQuarters.subclass(*args_, **kwargs_)
        else:
            return ForestQuarters(*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_forest_quarter(self):
        return self.forest_quarter
    def set_forest_quarter(self, forest_quarter):
        self.forest_quarter = forest_quarter
    def add_forest_quarter(self, value):
        self.forest_quarter.append(value)
    def insert_forest_quarter_at(self, index, value):
        self.forest_quarter.insert(index, value)
    def replace_forest_quarter_at(self, index, value):
        self.forest_quarter[index] = value
    def has__content(self):
        if (
            self.forest_quarter
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ForestQuarters', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ForestQuarters')
        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_ == 'ForestQuarters':
            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_='ForestQuarters')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ForestQuarters', 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_='ForestQuarters'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ForestQuarters', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for forest_quarter_ in self.forest_quarter:
            namespaceprefix_ = self.forest_quarter_nsprefix_ + ':' if (UseCapturedNS_ and self.forest_quarter_nsprefix_) else ''
            forest_quarter_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forest_quarter', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'forest_quarter':
            obj_ = ForestQuarter.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forest_quarter.append(obj_)
            obj_.original_tagname_ = 'forest_quarter'
# end class ForestQuarters


class ForestQuarter(GeneratedsSuper):
    """ForestQuarter -- Н
    о
    м
    е
    р
    л
    е
    с
    н
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    number -- Н
    о
    м
    е
    р
    к
    в
    а
    р
    т
    а
    л
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number=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.number = number
        self.number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ForestQuarter)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ForestQuarter.subclass:
            return ForestQuarter.subclass(*args_, **kwargs_)
        else:
            return ForestQuarter(*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 has__content(self):
        if (
            self.number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ForestQuarter', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ForestQuarter')
        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_ == 'ForestQuarter':
            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_='ForestQuarter')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ForestQuarter', 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_='ForestQuarter'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ForestQuarter', 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_))
    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):
        pass
    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
# end class ForestQuarter


class Waters(GeneratedsSuper):
    """Waters -- В
    о
    д
    н
    ы
    е
    о
    б
    ъ
    е
    к
    т
    ы
    water -- В
    о
    д
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, water=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 water is None:
            self.water = []
        else:
            self.water = water
        self.water_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Waters)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Waters.subclass:
            return Waters.subclass(*args_, **kwargs_)
        else:
            return Waters(*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_water(self):
        return self.water
    def set_water(self, water):
        self.water = water
    def add_water(self, value):
        self.water.append(value)
    def insert_water_at(self, index, value):
        self.water.insert(index, value)
    def replace_water_at(self, index, value):
        self.water[index] = value
    def has__content(self):
        if (
            self.water
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Waters', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Waters')
        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_ == 'Waters':
            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_='Waters')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Waters', 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_='Waters'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Waters', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for water_ in self.water:
            namespaceprefix_ = self.water_nsprefix_ + ':' if (UseCapturedNS_ and self.water_nsprefix_) else ''
            water_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='water', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'water':
            obj_ = Water.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.water.append(obj_)
            obj_.original_tagname_ = 'water'
# end class Waters


class Water(GeneratedsSuper):
    """Water -- В
    о
    д
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    (
    в
    и
    д
    ,
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    )
    water_object_type -- В
    и
    д
    в
    о
    д
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    water_object_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    в
    о
    д
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, water_object_type=None, water_object_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.water_object_type = water_object_type
        self.water_object_type_nsprefix_ = None
        self.water_object_name = water_object_name
        self.water_object_name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Water)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Water.subclass:
            return Water.subclass(*args_, **kwargs_)
        else:
            return Water(*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_water_object_type(self):
        return self.water_object_type
    def set_water_object_type(self, water_object_type):
        self.water_object_type = water_object_type
    def get_water_object_name(self):
        return self.water_object_name
    def set_water_object_name(self, water_object_name):
        self.water_object_name = water_object_name
    def has__content(self):
        if (
            self.water_object_type is not None or
            self.water_object_name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Water', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Water')
        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_ == 'Water':
            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_='Water')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Water', 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_='Water'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Water', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.water_object_type is not None:
            namespaceprefix_ = self.water_object_type_nsprefix_ + ':' if (UseCapturedNS_ and self.water_object_type_nsprefix_) else ''
            self.water_object_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='water_object_type', pretty_print=pretty_print)
        if self.water_object_name is not None:
            namespaceprefix_ = self.water_object_name_nsprefix_ + ':' if (UseCapturedNS_ and self.water_object_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%swater_object_name>%s</%swater_object_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.water_object_name), input_name='water_object_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'water_object_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.water_object_type = obj_
            obj_.original_tagname_ = 'water_object_type'
        elif nodeName_ == 'water_object_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'water_object_name')
            value_ = self.gds_validate_string(value_, node, 'water_object_name')
            self.water_object_name = value_
            self.water_object_name_nsprefix_ = child_.prefix
# end class Water


class GovernmentLandSupervision(GeneratedsSuper):
    """GovernmentLandSupervision -- Г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    й
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    н
    а
    д
    з
    о
    р
    supervision_events -- Н
    а
    д
    з
    о
    р
    н
    ы
    е
    м
    е
    р
    о
    п
    р
    и
    я
    т
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, supervision_events=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.supervision_events = supervision_events
        self.supervision_events_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, GovernmentLandSupervision)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if GovernmentLandSupervision.subclass:
            return GovernmentLandSupervision.subclass(*args_, **kwargs_)
        else:
            return GovernmentLandSupervision(*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_supervision_events(self):
        return self.supervision_events
    def set_supervision_events(self, supervision_events):
        self.supervision_events = supervision_events
    def has__content(self):
        if (
            self.supervision_events is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='GovernmentLandSupervision', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('GovernmentLandSupervision')
        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_ == 'GovernmentLandSupervision':
            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_='GovernmentLandSupervision')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GovernmentLandSupervision', 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_='GovernmentLandSupervision'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='GovernmentLandSupervision', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.supervision_events is not None:
            namespaceprefix_ = self.supervision_events_nsprefix_ + ':' if (UseCapturedNS_ and self.supervision_events_nsprefix_) else ''
            self.supervision_events.export(outfile, level, namespaceprefix_, namespacedef_='', name_='supervision_events', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'supervision_events':
            obj_ = SupervisionEvents.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.supervision_events = obj_
            obj_.original_tagname_ = 'supervision_events'
# end class GovernmentLandSupervision


class SupervisionEvents(GeneratedsSuper):
    """SupervisionEvents -- Н
    а
    д
    з
    о
    р
    н
    ы
    е
    м
    е
    р
    о
    п
    р
    и
    я
    т
    и
    я
      
    * supervision_event -- Н
      а
      д
      з
      о
      р
      н
      о
      е
      м
      е
      р
      о
      п
      р
      и
      я
      т
      и
      е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, supervision_event=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 supervision_event is None:
            self.supervision_event = []
        else:
            self.supervision_event = supervision_event
        self.supervision_event_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SupervisionEvents)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SupervisionEvents.subclass:
            return SupervisionEvents.subclass(*args_, **kwargs_)
        else:
            return SupervisionEvents(*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_supervision_event(self):
        return self.supervision_event
    def set_supervision_event(self, supervision_event):
        self.supervision_event = supervision_event
    def add_supervision_event(self, value):
        self.supervision_event.append(value)
    def insert_supervision_event_at(self, index, value):
        self.supervision_event.insert(index, value)
    def replace_supervision_event_at(self, index, value):
        self.supervision_event[index] = value
    def has__content(self):
        if (
            self.supervision_event
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SupervisionEvents', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SupervisionEvents')
        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_ == 'SupervisionEvents':
            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_='SupervisionEvents')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SupervisionEvents', 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_='SupervisionEvents'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SupervisionEvents', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for supervision_event_ in self.supervision_event:
            namespaceprefix_ = self.supervision_event_nsprefix_ + ':' if (UseCapturedNS_ and self.supervision_event_nsprefix_) else ''
            supervision_event_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='supervision_event', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'supervision_event':
            obj_ = SupervisionEvent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.supervision_event.append(obj_)
            obj_.original_tagname_ = 'supervision_event'
# end class SupervisionEvents


class SupervisionEvent(GeneratedsSuper):
    """SupervisionEvent -- Н
    а
    д
    з
    о
    р
    н
    о
    е
    м
    е
    р
    о
    п
    р
    и
    я
    т
    и
    е
    agency -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    р
    г
    а
    н
    а
    ,
    п
    р
    о
    в
    о
    д
    и
    в
    ш
    е
    г
    о
    м
    е
    р
    о
    п
    р
    и
    я
    т
    и
    е
    п
    о
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    м
    у
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    н
    а
    д
    з
    о
    р
    у
    event_name -- М
    е
    р
    о
    п
    р
    и
    я
    т
    и
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    г
    о
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    н
    а
    д
    з
    о
    р
    а
    п
    о
    с
    о
    б
    л
    ю
    д
    е
    н
    и
    ю
    т
    р
    е
    б
    о
    в
    а
    н
    и
    й
    з
    а
    к
    о
    н
    о
    д
    а
    т
    е
    л
    ь
    с
    т
    в
    а
    (
    п
    л
    а
    н
    о
    в
    а
    я
    ,
    в
    н
    е
    п
    л
    а
    н
    о
    в
    а
    я
    п
    р
    о
    в
    е
    р
    к
    а
    ,
    а
    д
    м
    и
    н
    и
    с
    т
    р
    а
    т
    и
    в
    н
    о
    е
    о
    б
    с
    л
    е
    д
    о
    в
    а
    н
    и
    е
    )
    event_form -- Ф
    о
    р
    м
    а
    п
    р
    о
    в
    е
    д
    е
    н
    и
    я
    п
    л
    а
    н
    о
    в
    о
    й
    и
    л
    и
    в
    н
    е
    п
    л
    а
    н
    о
    в
    о
    й
    п
    р
    о
    в
    е
    р
    к
    и
    inspection_end -- Д
    а
    т
    а
    о
    к
    о
    н
    ч
    а
    н
    и
    я
    п
    р
    о
    в
    е
    р
    к
    и
    results_event -- Р
    е
    з
    у
    л
    ь
    т
    а
    т
    ы
    п
    р
    о
    в
    е
    д
    е
    н
    н
    о
    г
    о
    м
    е
    р
    о
    п
    р
    и
    я
    т
    и
    я
    doc_requisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    о
    ф
    о
    р
    м
    л
    е
    н
    н
    ы
    х
    д
    о
    к
    у
    м
    е
    н
    т
    о
    в
    elimination -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    у
    с
    т
    р
    а
    н
    е
    н
    и
    и
    в
    ы
    я
    в
    л
    е
    н
    н
    о
    г
    о
    н
    а
    р
    у
    ш
    е
    н
    и
    я
    elimination_doc_requisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    д
    о
    к
    у
    м
    е
    н
    т
    а
    ,
    с
    о
    д
    е
    р
    ж
    а
    щ
    е
    г
    о
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    у
    с
    т
    р
    а
    н
    е
    н
    и
    и
    п
    р
    а
    в
    о
    н
    а
    р
    у
    ш
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, agency=None, event_name=None, event_form=None, inspection_end=None, results_event=None, doc_requisites=None, elimination=None, elimination_doc_requisites=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.agency = agency
        self.agency_nsprefix_ = None
        self.event_name = event_name
        self.event_name_nsprefix_ = None
        self.event_form = event_form
        self.event_form_nsprefix_ = None
        if isinstance(inspection_end, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(inspection_end, '%Y-%m-%d').date()
        else:
            initvalue_ = inspection_end
        self.inspection_end = initvalue_
        self.inspection_end_nsprefix_ = None
        self.results_event = results_event
        self.results_event_nsprefix_ = None
        self.doc_requisites = doc_requisites
        self.doc_requisites_nsprefix_ = None
        self.elimination = elimination
        self.elimination_nsprefix_ = None
        self.elimination_doc_requisites = elimination_doc_requisites
        self.elimination_doc_requisites_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SupervisionEvent)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SupervisionEvent.subclass:
            return SupervisionEvent.subclass(*args_, **kwargs_)
        else:
            return SupervisionEvent(*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_agency(self):
        return self.agency
    def set_agency(self, agency):
        self.agency = agency
    def get_event_name(self):
        return self.event_name
    def set_event_name(self, event_name):
        self.event_name = event_name
    def get_event_form(self):
        return self.event_form
    def set_event_form(self, event_form):
        self.event_form = event_form
    def get_inspection_end(self):
        return self.inspection_end
    def set_inspection_end(self, inspection_end):
        self.inspection_end = inspection_end
    def get_results_event(self):
        return self.results_event
    def set_results_event(self, results_event):
        self.results_event = results_event
    def get_doc_requisites(self):
        return self.doc_requisites
    def set_doc_requisites(self, doc_requisites):
        self.doc_requisites = doc_requisites
    def get_elimination(self):
        return self.elimination
    def set_elimination(self, elimination):
        self.elimination = elimination
    def get_elimination_doc_requisites(self):
        return self.elimination_doc_requisites
    def set_elimination_doc_requisites(self, elimination_doc_requisites):
        self.elimination_doc_requisites = elimination_doc_requisites
    def has__content(self):
        if (
            self.agency is not None or
            self.event_name is not None or
            self.event_form is not None or
            self.inspection_end is not None or
            self.results_event is not None or
            self.doc_requisites is not None or
            self.elimination is not None or
            self.elimination_doc_requisites is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SupervisionEvent', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SupervisionEvent')
        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_ == 'SupervisionEvent':
            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_='SupervisionEvent')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SupervisionEvent', 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_='SupervisionEvent'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SupervisionEvent', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.agency is not None:
            namespaceprefix_ = self.agency_nsprefix_ + ':' if (UseCapturedNS_ and self.agency_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sagency>%s</%sagency>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.agency), input_name='agency')), namespaceprefix_ , eol_))
        if self.event_name is not None:
            namespaceprefix_ = self.event_name_nsprefix_ + ':' if (UseCapturedNS_ and self.event_name_nsprefix_) else ''
            self.event_name.export(outfile, level, namespaceprefix_, namespacedef_='', name_='event_name', pretty_print=pretty_print)
        if self.event_form is not None:
            namespaceprefix_ = self.event_form_nsprefix_ + ':' if (UseCapturedNS_ and self.event_form_nsprefix_) else ''
            self.event_form.export(outfile, level, namespaceprefix_, namespacedef_='', name_='event_form', pretty_print=pretty_print)
        if self.inspection_end is not None:
            namespaceprefix_ = self.inspection_end_nsprefix_ + ':' if (UseCapturedNS_ and self.inspection_end_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sinspection_end>%s</%sinspection_end>%s' % (namespaceprefix_ , self.gds_format_date(self.inspection_end, input_name='inspection_end'), namespaceprefix_ , eol_))
        if self.results_event is not None:
            namespaceprefix_ = self.results_event_nsprefix_ + ':' if (UseCapturedNS_ and self.results_event_nsprefix_) else ''
            self.results_event.export(outfile, level, namespaceprefix_, namespacedef_='', name_='results_event', pretty_print=pretty_print)
        if self.doc_requisites is not None:
            namespaceprefix_ = self.doc_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.doc_requisites_nsprefix_) else ''
            self.doc_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='doc_requisites', pretty_print=pretty_print)
        if self.elimination is not None:
            namespaceprefix_ = self.elimination_nsprefix_ + ':' if (UseCapturedNS_ and self.elimination_nsprefix_) else ''
            self.elimination.export(outfile, level, namespaceprefix_, namespacedef_='', name_='elimination', pretty_print=pretty_print)
        if self.elimination_doc_requisites is not None:
            namespaceprefix_ = self.elimination_doc_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.elimination_doc_requisites_nsprefix_) else ''
            self.elimination_doc_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='elimination_doc_requisites', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'agency':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'agency')
            value_ = self.gds_validate_string(value_, node, 'agency')
            self.agency = value_
            self.agency_nsprefix_ = child_.prefix
        elif nodeName_ == 'event_name':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.event_name = obj_
            obj_.original_tagname_ = 'event_name'
        elif nodeName_ == 'event_form':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.event_form = obj_
            obj_.original_tagname_ = 'event_form'
        elif nodeName_ == 'inspection_end':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.inspection_end = dval_
            self.inspection_end_nsprefix_ = child_.prefix
        elif nodeName_ == 'results_event':
            obj_ = ResultsEvent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.results_event = obj_
            obj_.original_tagname_ = 'results_event'
        elif nodeName_ == 'doc_requisites':
            obj_ = DocRequisites.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.doc_requisites = obj_
            obj_.original_tagname_ = 'doc_requisites'
        elif nodeName_ == 'elimination':
            obj_ = EliminationType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.elimination = obj_
            obj_.original_tagname_ = 'elimination'
        elif nodeName_ == 'elimination_doc_requisites':
            obj_ = DocRequisite.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.elimination_doc_requisites = obj_
            obj_.original_tagname_ = 'elimination_doc_requisites'
# end class SupervisionEvent


class ResultsEvent(GeneratedsSuper):
    """ResultsEvent -- Р
    е
    з
    у
    л
    ь
    т
    а
    т
    ы
    п
    р
    о
    в
    е
    д
    е
    н
    н
    о
    г
    о
    м
    е
    р
    о
    п
    р
    и
    я
    т
    и
    я
    availability_violations -- Н
    а
    л
    и
    ч
    и
    е
    п
    р
    а
    в
    о
    н
    а
    р
    у
    ш
    е
    н
    и
    я
    identified_violations -- В
    ы
    я
    в
    л
    е
    н
    н
    о
    е
    п
    р
    а
    в
    о
    н
    а
    р
    у
    ш
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, availability_violations=None, identified_violations=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.availability_violations = availability_violations
        self.availability_violations_nsprefix_ = None
        self.identified_violations = identified_violations
        self.identified_violations_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ResultsEvent)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ResultsEvent.subclass:
            return ResultsEvent.subclass(*args_, **kwargs_)
        else:
            return ResultsEvent(*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_availability_violations(self):
        return self.availability_violations
    def set_availability_violations(self, availability_violations):
        self.availability_violations = availability_violations
    def get_identified_violations(self):
        return self.identified_violations
    def set_identified_violations(self, identified_violations):
        self.identified_violations = identified_violations
    def has__content(self):
        if (
            self.availability_violations is not None or
            self.identified_violations is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ResultsEvent', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ResultsEvent')
        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_ == 'ResultsEvent':
            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_='ResultsEvent')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ResultsEvent', 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_='ResultsEvent'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ResultsEvent', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.availability_violations is not None:
            namespaceprefix_ = self.availability_violations_nsprefix_ + ':' if (UseCapturedNS_ and self.availability_violations_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%savailability_violations>%s</%savailability_violations>%s' % (namespaceprefix_ , self.gds_format_boolean(self.availability_violations, input_name='availability_violations'), namespaceprefix_ , eol_))
        if self.identified_violations is not None:
            namespaceprefix_ = self.identified_violations_nsprefix_ + ':' if (UseCapturedNS_ and self.identified_violations_nsprefix_) else ''
            self.identified_violations.export(outfile, level, namespaceprefix_, namespacedef_='', name_='identified_violations', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'availability_violations':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'availability_violations')
            ival_ = self.gds_validate_boolean(ival_, node, 'availability_violations')
            self.availability_violations = ival_
            self.availability_violations_nsprefix_ = child_.prefix
        elif nodeName_ == 'identified_violations':
            obj_ = IdentifiedViolations.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.identified_violations = obj_
            obj_.original_tagname_ = 'identified_violations'
# end class ResultsEvent


class IdentifiedViolations(GeneratedsSuper):
    """IdentifiedViolations -- В
    ы
    я
    в
    л
    е
    н
    н
    о
    е
    п
    р
    а
    в
    о
    н
    а
    р
    у
    ш
    е
    н
    и
    е
    type_violations -- В
    и
    д
    в
    ы
    я
    в
    л
    е
    н
    н
    о
    г
    о
    п
    р
    а
    в
    о
    н
    а
    р
    у
    ш
    е
    н
    и
    я
    sign_violations -- П
    р
    и
    з
    н
    а
    к
    и
    в
    ы
    я
    в
    л
    е
    н
    н
    о
    г
    о
    п
    р
    а
    в
    о
    н
    а
    р
    у
    ш
    е
    н
    и
    я
    area -- П
    л
    о
    щ
    а
    д
    ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_violations=None, sign_violations=None, area=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.type_violations = type_violations
        self.type_violations_nsprefix_ = None
        self.sign_violations = sign_violations
        self.sign_violations_nsprefix_ = None
        self.area = area
        self.area_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IdentifiedViolations)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IdentifiedViolations.subclass:
            return IdentifiedViolations.subclass(*args_, **kwargs_)
        else:
            return IdentifiedViolations(*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_type_violations(self):
        return self.type_violations
    def set_type_violations(self, type_violations):
        self.type_violations = type_violations
    def get_sign_violations(self):
        return self.sign_violations
    def set_sign_violations(self, sign_violations):
        self.sign_violations = sign_violations
    def get_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def has__content(self):
        if (
            self.type_violations is not None or
            self.sign_violations is not None or
            self.area is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IdentifiedViolations', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IdentifiedViolations')
        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_ == 'IdentifiedViolations':
            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_='IdentifiedViolations')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IdentifiedViolations', 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_='IdentifiedViolations'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IdentifiedViolations', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_violations is not None:
            namespaceprefix_ = self.type_violations_nsprefix_ + ':' if (UseCapturedNS_ and self.type_violations_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_violations>%s</%stype_violations>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_violations), input_name='type_violations')), namespaceprefix_ , eol_))
        if self.sign_violations is not None:
            namespaceprefix_ = self.sign_violations_nsprefix_ + ':' if (UseCapturedNS_ and self.sign_violations_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssign_violations>%s</%ssign_violations>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.sign_violations), input_name='sign_violations')), namespaceprefix_ , eol_))
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_violations':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_violations')
            value_ = self.gds_validate_string(value_, node, 'type_violations')
            self.type_violations = value_
            self.type_violations_nsprefix_ = child_.prefix
        elif nodeName_ == 'sign_violations':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'sign_violations')
            value_ = self.gds_validate_string(value_, node, 'sign_violations')
            self.sign_violations = value_
            self.sign_violations_nsprefix_ = child_.prefix
        elif nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
# end class IdentifiedViolations


class DocRequisites(GeneratedsSuper):
    """DocRequisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    о
    ф
    о
    р
    м
    л
    е
    н
    н
    ы
    х
    д
    о
    к
    у
    м
    е
    н
    т
    о
    в
    doc_requisite -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    о
    ф
    о
    р
    м
    л
    е
    н
    н
    о
    г
    о
    д
    о
    к
    у
    м
    е
    н
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, doc_requisite=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 doc_requisite is None:
            self.doc_requisite = []
        else:
            self.doc_requisite = doc_requisite
        self.doc_requisite_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DocRequisites)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DocRequisites.subclass:
            return DocRequisites.subclass(*args_, **kwargs_)
        else:
            return DocRequisites(*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_doc_requisite(self):
        return self.doc_requisite
    def set_doc_requisite(self, doc_requisite):
        self.doc_requisite = doc_requisite
    def add_doc_requisite(self, value):
        self.doc_requisite.append(value)
    def insert_doc_requisite_at(self, index, value):
        self.doc_requisite.insert(index, value)
    def replace_doc_requisite_at(self, index, value):
        self.doc_requisite[index] = value
    def has__content(self):
        if (
            self.doc_requisite
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocRequisites', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DocRequisites')
        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_ == 'DocRequisites':
            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_='DocRequisites')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DocRequisites', 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_='DocRequisites'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocRequisites', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for doc_requisite_ in self.doc_requisite:
            namespaceprefix_ = self.doc_requisite_nsprefix_ + ':' if (UseCapturedNS_ and self.doc_requisite_nsprefix_) else ''
            doc_requisite_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='doc_requisite', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'doc_requisite':
            obj_ = DocRequisite.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.doc_requisite.append(obj_)
            obj_.original_tagname_ = 'doc_requisite'
# end class DocRequisites


class EliminationType(GeneratedsSuper):
    """EliminationType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    у
    с
    т
    р
    а
    н
    е
    н
    и
    и
    в
    ы
    я
    в
    л
    е
    н
    н
    о
    г
    о
    н
    а
    р
    у
    ш
    е
    н
    и
    я
    elimination_mark -- У
    с
    т
    р
    а
    н
    е
    н
    о
    elimination_agency -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    р
    г
    а
    н
    а
    ,
    п
    р
    и
    н
    я
    в
    ш
    е
    г
    о
    р
    е
    ш
    е
    н
    и
    е
    о
    б
    у
    с
    т
    р
    а
    н
    е
    н
    и
    и
    п
    р
    а
    в
    о
    н
    а
    р
    у
    ш
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, elimination_mark=None, elimination_agency=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.elimination_mark = elimination_mark
        self.elimination_mark_nsprefix_ = None
        self.elimination_agency = elimination_agency
        self.elimination_agency_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, EliminationType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if EliminationType.subclass:
            return EliminationType.subclass(*args_, **kwargs_)
        else:
            return EliminationType(*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_elimination_mark(self):
        return self.elimination_mark
    def set_elimination_mark(self, elimination_mark):
        self.elimination_mark = elimination_mark
    def get_elimination_agency(self):
        return self.elimination_agency
    def set_elimination_agency(self, elimination_agency):
        self.elimination_agency = elimination_agency
    def has__content(self):
        if (
            self.elimination_mark is not None or
            self.elimination_agency is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EliminationType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('EliminationType')
        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_ == 'EliminationType':
            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_='EliminationType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='EliminationType', 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_='EliminationType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EliminationType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.elimination_mark is not None:
            namespaceprefix_ = self.elimination_mark_nsprefix_ + ':' if (UseCapturedNS_ and self.elimination_mark_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%selimination_mark>%s</%selimination_mark>%s' % (namespaceprefix_ , self.gds_format_boolean(self.elimination_mark, input_name='elimination_mark'), namespaceprefix_ , eol_))
        if self.elimination_agency is not None:
            namespaceprefix_ = self.elimination_agency_nsprefix_ + ':' if (UseCapturedNS_ and self.elimination_agency_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%selimination_agency>%s</%selimination_agency>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.elimination_agency), input_name='elimination_agency')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'elimination_mark':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'elimination_mark')
            ival_ = self.gds_validate_boolean(ival_, node, 'elimination_mark')
            self.elimination_mark = ival_
            self.elimination_mark_nsprefix_ = child_.prefix
        elif nodeName_ == 'elimination_agency':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'elimination_agency')
            value_ = self.gds_validate_string(value_, node, 'elimination_agency')
            self.elimination_agency = value_
            self.elimination_agency_nsprefix_ = child_.prefix
# end class EliminationType


class RightRecordsBaseParams(GeneratedsSuper):
    """RightRecordsBaseParams -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_record=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 right_record is None:
            self.right_record = []
        else:
            self.right_record = right_record
        self.right_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightRecordsBaseParams)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightRecordsBaseParams.subclass:
            return RightRecordsBaseParams.subclass(*args_, **kwargs_)
        else:
            return RightRecordsBaseParams(*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_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def add_right_record(self, value):
        self.right_record.append(value)
    def insert_right_record_at(self, index, value):
        self.right_record.insert(index, value)
    def replace_right_record_at(self, index, value):
        self.right_record[index] = value
    def has__content(self):
        if (
            self.right_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordsBaseParams', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightRecordsBaseParams')
        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_ == 'RightRecordsBaseParams':
            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_='RightRecordsBaseParams')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightRecordsBaseParams', 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_='RightRecordsBaseParams'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordsBaseParams', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for right_record_ in self.right_record:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            right_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_record':
            obj_ = right_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record.append(obj_)
            obj_.original_tagname_ = 'right_record'
# end class RightRecordsBaseParams


class RightRecordsAboutProperty(GeneratedsSuper):
    """RightRecordsAboutProperty -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_record=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 right_record is None:
            self.right_record = []
        else:
            self.right_record = right_record
        self.right_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightRecordsAboutProperty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightRecordsAboutProperty.subclass:
            return RightRecordsAboutProperty.subclass(*args_, **kwargs_)
        else:
            return RightRecordsAboutProperty(*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_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def add_right_record(self, value):
        self.right_record.append(value)
    def insert_right_record_at(self, index, value):
        self.right_record.insert(index, value)
    def replace_right_record_at(self, index, value):
        self.right_record[index] = value
    def has__content(self):
        if (
            self.right_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordsAboutProperty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightRecordsAboutProperty')
        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_ == 'RightRecordsAboutProperty':
            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_='RightRecordsAboutProperty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightRecordsAboutProperty', 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_='RightRecordsAboutProperty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordsAboutProperty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for right_record_ in self.right_record:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            right_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_record':
            obj_ = right_recordType3.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record.append(obj_)
            obj_.original_tagname_ = 'right_record'
# end class RightRecordsAboutProperty


class RightData(GeneratedsSuper):
    """RightData -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    right_type -- В
    и
    д
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    в
    е
    щ
    н
    о
    г
    о
    п
    р
    а
    в
    а
    right_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    в
    е
    щ
    н
    о
    г
    о
    п
    р
    а
    в
    а
    shares -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    share_description -- О
    п
    и
    с
    а
    н
    и
    е
    д
    о
    л
    и
    т
    е
    к
    с
    т
    о
    м
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_type=None, right_number=None, shares=None, share_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.right_type = right_type
        self.right_type_nsprefix_ = None
        self.right_number = right_number
        self.right_number_nsprefix_ = None
        self.shares = shares
        self.shares_nsprefix_ = None
        self.share_description = share_description
        self.share_description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightData)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightData.subclass:
            return RightData.subclass(*args_, **kwargs_)
        else:
            return RightData(*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_right_type(self):
        return self.right_type
    def set_right_type(self, right_type):
        self.right_type = right_type
    def get_right_number(self):
        return self.right_number
    def set_right_number(self, right_number):
        self.right_number = right_number
    def get_shares(self):
        return self.shares
    def set_shares(self, shares):
        self.shares = shares
    def get_share_description(self):
        return self.share_description
    def set_share_description(self, share_description):
        self.share_description = share_description
    def has__content(self):
        if (
            self.right_type is not None or
            self.right_number is not None or
            self.shares is not None or
            self.share_description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightData', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightData')
        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_ == 'RightData':
            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_='RightData')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightData', 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_='RightData'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightData', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.right_type is not None:
            namespaceprefix_ = self.right_type_nsprefix_ + ':' if (UseCapturedNS_ and self.right_type_nsprefix_) else ''
            self.right_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_type', pretty_print=pretty_print)
        if self.right_number is not None:
            namespaceprefix_ = self.right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.right_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sright_number>%s</%sright_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.right_number), input_name='right_number')), namespaceprefix_ , eol_))
        if self.shares is not None:
            namespaceprefix_ = self.shares_nsprefix_ + ':' if (UseCapturedNS_ and self.shares_nsprefix_) else ''
            self.shares.export(outfile, level, namespaceprefix_, namespacedef_='', name_='shares', pretty_print=pretty_print)
        if self.share_description is not None:
            namespaceprefix_ = self.share_description_nsprefix_ + ':' if (UseCapturedNS_ and self.share_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sshare_description>%s</%sshare_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.share_description), input_name='share_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_type = obj_
            obj_.original_tagname_ = 'right_type'
        elif nodeName_ == 'right_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'right_number')
            value_ = self.gds_validate_string(value_, node, 'right_number')
            self.right_number = value_
            self.right_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'shares':
            obj_ = Shares.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.shares = obj_
            obj_.original_tagname_ = 'shares'
        elif nodeName_ == 'share_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'share_description')
            value_ = self.gds_validate_string(value_, node, 'share_description')
            self.share_description = value_
            self.share_description_nsprefix_ = child_.prefix
# end class RightData


class RightDataReinstatement(GeneratedsSuper):
    """RightDataReinstatement -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    в
    о
    с
    с
    т
    а
    н
    о
    в
    л
    е
    н
    и
    е
    п
    р
    а
    в
    )
    right_type -- В
    и
    д
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    в
    е
    щ
    н
    о
    г
    о
    п
    р
    а
    в
    а
    right_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    в
    е
    щ
    н
    о
    г
    о
    п
    р
    а
    в
    а
    shares -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    share_description -- О
    п
    и
    с
    а
    н
    и
    е
    д
    о
    л
    и
    т
    е
    к
    с
    т
    о
    м
    reinstatement -- В
    о
    с
    с
    т
    а
    н
    о
    в
    л
    е
    н
    и
    е
    п
    р
    а
    в
    а
    н
    а
    о
    с
    н
    о
    в
    а
    н
    и
    и
    с
    у
    д
    е
    б
    н
    о
    г
    о
    а
    к
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_type=None, right_number=None, shares=None, share_description=None, reinstatement=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.right_type = right_type
        self.right_type_nsprefix_ = None
        self.right_number = right_number
        self.right_number_nsprefix_ = None
        self.shares = shares
        self.shares_nsprefix_ = None
        self.share_description = share_description
        self.share_description_nsprefix_ = None
        self.reinstatement = reinstatement
        self.reinstatement_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightDataReinstatement)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightDataReinstatement.subclass:
            return RightDataReinstatement.subclass(*args_, **kwargs_)
        else:
            return RightDataReinstatement(*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_right_type(self):
        return self.right_type
    def set_right_type(self, right_type):
        self.right_type = right_type
    def get_right_number(self):
        return self.right_number
    def set_right_number(self, right_number):
        self.right_number = right_number
    def get_shares(self):
        return self.shares
    def set_shares(self, shares):
        self.shares = shares
    def get_share_description(self):
        return self.share_description
    def set_share_description(self, share_description):
        self.share_description = share_description
    def get_reinstatement(self):
        return self.reinstatement
    def set_reinstatement(self, reinstatement):
        self.reinstatement = reinstatement
    def has__content(self):
        if (
            self.right_type is not None or
            self.right_number is not None or
            self.shares is not None or
            self.share_description is not None or
            self.reinstatement is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightDataReinstatement', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightDataReinstatement')
        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_ == 'RightDataReinstatement':
            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_='RightDataReinstatement')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightDataReinstatement', 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_='RightDataReinstatement'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightDataReinstatement', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.right_type is not None:
            namespaceprefix_ = self.right_type_nsprefix_ + ':' if (UseCapturedNS_ and self.right_type_nsprefix_) else ''
            self.right_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_type', pretty_print=pretty_print)
        if self.right_number is not None:
            namespaceprefix_ = self.right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.right_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sright_number>%s</%sright_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.right_number), input_name='right_number')), namespaceprefix_ , eol_))
        if self.shares is not None:
            namespaceprefix_ = self.shares_nsprefix_ + ':' if (UseCapturedNS_ and self.shares_nsprefix_) else ''
            self.shares.export(outfile, level, namespaceprefix_, namespacedef_='', name_='shares', pretty_print=pretty_print)
        if self.share_description is not None:
            namespaceprefix_ = self.share_description_nsprefix_ + ':' if (UseCapturedNS_ and self.share_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sshare_description>%s</%sshare_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.share_description), input_name='share_description')), namespaceprefix_ , eol_))
        if self.reinstatement is not None:
            namespaceprefix_ = self.reinstatement_nsprefix_ + ':' if (UseCapturedNS_ and self.reinstatement_nsprefix_) else ''
            self.reinstatement.export(outfile, level, namespaceprefix_, namespacedef_='', name_='reinstatement', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_type = obj_
            obj_.original_tagname_ = 'right_type'
        elif nodeName_ == 'right_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'right_number')
            value_ = self.gds_validate_string(value_, node, 'right_number')
            self.right_number = value_
            self.right_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'shares':
            obj_ = Shares.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.shares = obj_
            obj_.original_tagname_ = 'shares'
        elif nodeName_ == 'share_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'share_description')
            value_ = self.gds_validate_string(value_, node, 'share_description')
            self.share_description = value_
            self.share_description_nsprefix_ = child_.prefix
        elif nodeName_ == 'reinstatement':
            obj_ = ReinstatementDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.reinstatement = obj_
            obj_.original_tagname_ = 'reinstatement'
# end class RightDataReinstatement


class RightDataAndCancel(GeneratedsSuper):
    """RightDataAndCancel -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    (
    п
    е
    р
    е
    х
    о
    д
    е
    /
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    и
    п
    р
    а
    в
    а
    )
    right_type -- В
    и
    д
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    в
    е
    щ
    н
    о
    г
    о
    п
    р
    а
    в
    а
    right_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    в
    е
    щ
    н
    о
    г
    о
    п
    р
    а
    в
    а
    shares -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    share_description -- О
    п
    и
    с
    а
    н
    и
    е
    д
    о
    л
    и
    т
    е
    к
    с
    т
    о
    м
    cancel_right_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    е
    р
    е
    х
    о
    д
    а
    /
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    я
    п
    р
    а
    в
    а
    new_arose_right_numbers -- Н
    о
    м
    е
    р
    а
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    в
    н
    о
    в
    ь
    в
    о
    з
    н
    и
    к
    ш
    е
    г
    о
    п
    р
    а
    в
    а
    reinstatement -- В
    о
    с
    с
    т
    а
    н
    о
    в
    л
    е
    н
    и
    е
    п
    р
    а
    в
    а
    н
    а
    о
    с
    н
    о
    в
    а
    н
    и
    и
    с
    у
    д
    е
    б
    н
    о
    г
    о
    а
    к
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_type=None, right_number=None, shares=None, share_description=None, cancel_right_number=None, new_arose_right_numbers=None, reinstatement=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.right_type = right_type
        self.right_type_nsprefix_ = None
        self.right_number = right_number
        self.right_number_nsprefix_ = None
        self.shares = shares
        self.shares_nsprefix_ = None
        self.share_description = share_description
        self.share_description_nsprefix_ = None
        self.cancel_right_number = cancel_right_number
        self.cancel_right_number_nsprefix_ = None
        self.new_arose_right_numbers = new_arose_right_numbers
        self.new_arose_right_numbers_nsprefix_ = None
        self.reinstatement = reinstatement
        self.reinstatement_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightDataAndCancel)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightDataAndCancel.subclass:
            return RightDataAndCancel.subclass(*args_, **kwargs_)
        else:
            return RightDataAndCancel(*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_right_type(self):
        return self.right_type
    def set_right_type(self, right_type):
        self.right_type = right_type
    def get_right_number(self):
        return self.right_number
    def set_right_number(self, right_number):
        self.right_number = right_number
    def get_shares(self):
        return self.shares
    def set_shares(self, shares):
        self.shares = shares
    def get_share_description(self):
        return self.share_description
    def set_share_description(self, share_description):
        self.share_description = share_description
    def get_cancel_right_number(self):
        return self.cancel_right_number
    def set_cancel_right_number(self, cancel_right_number):
        self.cancel_right_number = cancel_right_number
    def get_new_arose_right_numbers(self):
        return self.new_arose_right_numbers
    def set_new_arose_right_numbers(self, new_arose_right_numbers):
        self.new_arose_right_numbers = new_arose_right_numbers
    def get_reinstatement(self):
        return self.reinstatement
    def set_reinstatement(self, reinstatement):
        self.reinstatement = reinstatement
    def has__content(self):
        if (
            self.right_type is not None or
            self.right_number is not None or
            self.shares is not None or
            self.share_description is not None or
            self.cancel_right_number is not None or
            self.new_arose_right_numbers is not None or
            self.reinstatement is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightDataAndCancel', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightDataAndCancel')
        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_ == 'RightDataAndCancel':
            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_='RightDataAndCancel')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightDataAndCancel', 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_='RightDataAndCancel'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightDataAndCancel', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.right_type is not None:
            namespaceprefix_ = self.right_type_nsprefix_ + ':' if (UseCapturedNS_ and self.right_type_nsprefix_) else ''
            self.right_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_type', pretty_print=pretty_print)
        if self.right_number is not None:
            namespaceprefix_ = self.right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.right_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sright_number>%s</%sright_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.right_number), input_name='right_number')), namespaceprefix_ , eol_))
        if self.shares is not None:
            namespaceprefix_ = self.shares_nsprefix_ + ':' if (UseCapturedNS_ and self.shares_nsprefix_) else ''
            self.shares.export(outfile, level, namespaceprefix_, namespacedef_='', name_='shares', pretty_print=pretty_print)
        if self.share_description is not None:
            namespaceprefix_ = self.share_description_nsprefix_ + ':' if (UseCapturedNS_ and self.share_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sshare_description>%s</%sshare_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.share_description), input_name='share_description')), namespaceprefix_ , eol_))
        if self.cancel_right_number is not None:
            namespaceprefix_ = self.cancel_right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cancel_right_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scancel_right_number>%s</%scancel_right_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cancel_right_number), input_name='cancel_right_number')), namespaceprefix_ , eol_))
        if self.new_arose_right_numbers is not None:
            namespaceprefix_ = self.new_arose_right_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.new_arose_right_numbers_nsprefix_) else ''
            self.new_arose_right_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='new_arose_right_numbers', pretty_print=pretty_print)
        if self.reinstatement is not None:
            namespaceprefix_ = self.reinstatement_nsprefix_ + ':' if (UseCapturedNS_ and self.reinstatement_nsprefix_) else ''
            self.reinstatement.export(outfile, level, namespaceprefix_, namespacedef_='', name_='reinstatement', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_type = obj_
            obj_.original_tagname_ = 'right_type'
        elif nodeName_ == 'right_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'right_number')
            value_ = self.gds_validate_string(value_, node, 'right_number')
            self.right_number = value_
            self.right_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'shares':
            obj_ = Shares.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.shares = obj_
            obj_.original_tagname_ = 'shares'
        elif nodeName_ == 'share_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'share_description')
            value_ = self.gds_validate_string(value_, node, 'share_description')
            self.share_description = value_
            self.share_description_nsprefix_ = child_.prefix
        elif nodeName_ == 'cancel_right_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cancel_right_number')
            value_ = self.gds_validate_string(value_, node, 'cancel_right_number')
            self.cancel_right_number = value_
            self.cancel_right_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'new_arose_right_numbers':
            obj_ = NewAroseRightNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.new_arose_right_numbers = obj_
            obj_.original_tagname_ = 'new_arose_right_numbers'
        elif nodeName_ == 'reinstatement':
            obj_ = ReinstatementDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.reinstatement = obj_
            obj_.original_tagname_ = 'reinstatement'
# end class RightDataAndCancel


class NewAroseRightNumbers(GeneratedsSuper):
    """NewAroseRightNumbers -- Н
    о
    м
    е
    р
    а
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    в
    н
    о
    в
    ь
    в
    о
    з
    н
    и
    к
    ш
    е
    г
    о
    п
    р
    а
    в
    а
    new_arose_right_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    в
    н
    о
    в
    ь
    в
    о
    з
    н
    и
    к
    ш
    е
    г
    о
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, new_arose_right_number=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 new_arose_right_number is None:
            self.new_arose_right_number = []
        else:
            self.new_arose_right_number = new_arose_right_number
        self.new_arose_right_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, NewAroseRightNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if NewAroseRightNumbers.subclass:
            return NewAroseRightNumbers.subclass(*args_, **kwargs_)
        else:
            return NewAroseRightNumbers(*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_new_arose_right_number(self):
        return self.new_arose_right_number
    def set_new_arose_right_number(self, new_arose_right_number):
        self.new_arose_right_number = new_arose_right_number
    def add_new_arose_right_number(self, value):
        self.new_arose_right_number.append(value)
    def insert_new_arose_right_number_at(self, index, value):
        self.new_arose_right_number.insert(index, value)
    def replace_new_arose_right_number_at(self, index, value):
        self.new_arose_right_number[index] = value
    def has__content(self):
        if (
            self.new_arose_right_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NewAroseRightNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('NewAroseRightNumbers')
        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_ == 'NewAroseRightNumbers':
            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_='NewAroseRightNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NewAroseRightNumbers', 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_='NewAroseRightNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NewAroseRightNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for new_arose_right_number_ in self.new_arose_right_number:
            namespaceprefix_ = self.new_arose_right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.new_arose_right_number_nsprefix_) else ''
            new_arose_right_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='new_arose_right_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'new_arose_right_number':
            obj_ = RightRecordNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.new_arose_right_number.append(obj_)
            obj_.original_tagname_ = 'new_arose_right_number'
# end class NewAroseRightNumbers


class RightRecordsTransfer(GeneratedsSuper):
    """RightRecordsTransfer -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    п
    р
    и
    п
    е
    р
    е
    х
    о
    д
    е
    п
    р
    а
    в
    н
    а
    о
    б
    ъ
    е
    к
    т
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_record=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 right_record is None:
            self.right_record = []
        else:
            self.right_record = right_record
        self.right_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightRecordsTransfer)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightRecordsTransfer.subclass:
            return RightRecordsTransfer.subclass(*args_, **kwargs_)
        else:
            return RightRecordsTransfer(*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_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def add_right_record(self, value):
        self.right_record.append(value)
    def insert_right_record_at(self, index, value):
        self.right_record.insert(index, value)
    def replace_right_record_at(self, index, value):
        self.right_record[index] = value
    def has__content(self):
        if (
            self.right_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordsTransfer', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightRecordsTransfer')
        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_ == 'RightRecordsTransfer':
            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_='RightRecordsTransfer')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightRecordsTransfer', 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_='RightRecordsTransfer'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordsTransfer', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for right_record_ in self.right_record:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            right_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_record':
            obj_ = right_recordType4.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record.append(obj_)
            obj_.original_tagname_ = 'right_record'
# end class RightRecordsTransfer


class Changes(GeneratedsSuper):
    """Changes -- И
    з
    м
    е
    н
    е
    н
    и
    е
    р
    е
    е
    с
    т
    р
    о
    в
    ы
    х
    з
    а
    п
    и
    с
    е
    й
    change_record_number -- Н
    о
    м
    е
    р
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    я
    п
    р
    а
    в
    а
    fixed_at -- Д
    а
    т
    а
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    я
    п
    р
    а
    в
    а
    underlying_documents -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    е
    р
    е
    х
    о
    д
    а
    (
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    я
    )
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, change_record_number=None, fixed_at=None, underlying_documents=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.change_record_number = change_record_number
        self.change_record_number_nsprefix_ = None
        if isinstance(fixed_at, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(fixed_at, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = fixed_at
        self.fixed_at = initvalue_
        self.fixed_at_nsprefix_ = None
        self.underlying_documents = underlying_documents
        self.underlying_documents_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Changes)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Changes.subclass:
            return Changes.subclass(*args_, **kwargs_)
        else:
            return Changes(*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_change_record_number(self):
        return self.change_record_number
    def set_change_record_number(self, change_record_number):
        self.change_record_number = change_record_number
    def get_fixed_at(self):
        return self.fixed_at
    def set_fixed_at(self, fixed_at):
        self.fixed_at = fixed_at
    def get_underlying_documents(self):
        return self.underlying_documents
    def set_underlying_documents(self, underlying_documents):
        self.underlying_documents = underlying_documents
    def has__content(self):
        if (
            self.change_record_number is not None or
            self.fixed_at is not None or
            self.underlying_documents is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Changes', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Changes')
        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_ == 'Changes':
            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_='Changes')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Changes', 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_='Changes'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Changes', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.change_record_number is not None:
            namespaceprefix_ = self.change_record_number_nsprefix_ + ':' if (UseCapturedNS_ and self.change_record_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%schange_record_number>%s</%schange_record_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.change_record_number), input_name='change_record_number')), namespaceprefix_ , eol_))
        if self.fixed_at is not None:
            namespaceprefix_ = self.fixed_at_nsprefix_ + ':' if (UseCapturedNS_ and self.fixed_at_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfixed_at>%s</%sfixed_at>%s' % (namespaceprefix_ , self.gds_format_datetime(self.fixed_at, input_name='fixed_at'), namespaceprefix_ , eol_))
        if self.underlying_documents is not None:
            namespaceprefix_ = self.underlying_documents_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_documents_nsprefix_) else ''
            self.underlying_documents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_documents', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'change_record_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'change_record_number')
            value_ = self.gds_validate_string(value_, node, 'change_record_number')
            self.change_record_number = value_
            self.change_record_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'fixed_at':
            sval_ = child_.text
            dval_ = self.gds_parse_datetime(sval_)
            self.fixed_at = dval_
            self.fixed_at_nsprefix_ = child_.prefix
        elif nodeName_ == 'underlying_documents':
            obj_ = UnderlyingDocumentsMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_documents = obj_
            obj_.original_tagname_ = 'underlying_documents'
# end class Changes


class RightRecordIndivid(GeneratedsSuper):
    """RightRecordIndivid -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    record_info -- Д
    а
    т
    ы
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    right_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    underlying_documents -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, right_data=None, underlying_documents=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.right_data = right_data
        self.right_data_nsprefix_ = None
        self.underlying_documents = underlying_documents
        self.underlying_documents_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightRecordIndivid)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightRecordIndivid.subclass:
            return RightRecordIndivid.subclass(*args_, **kwargs_)
        else:
            return RightRecordIndivid(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_right_data(self):
        return self.right_data
    def set_right_data(self, right_data):
        self.right_data = right_data
    def get_underlying_documents(self):
        return self.underlying_documents
    def set_underlying_documents(self, underlying_documents):
        self.underlying_documents = underlying_documents
    def has__content(self):
        if (
            self.record_info is not None or
            self.right_data is not None or
            self.underlying_documents is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordIndivid', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightRecordIndivid')
        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_ == 'RightRecordIndivid':
            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_='RightRecordIndivid')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightRecordIndivid', 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_='RightRecordIndivid'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordIndivid', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.right_data is not None:
            namespaceprefix_ = self.right_data_nsprefix_ + ':' if (UseCapturedNS_ and self.right_data_nsprefix_) else ''
            self.right_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_data', pretty_print=pretty_print)
        if self.underlying_documents is not None:
            namespaceprefix_ = self.underlying_documents_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_documents_nsprefix_) else ''
            self.underlying_documents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_documents', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RecordInfo.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'right_data':
            obj_ = RightDataAndCancel.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_data = obj_
            obj_.original_tagname_ = 'right_data'
        elif nodeName_ == 'underlying_documents':
            obj_ = UnderlyingDocumentsOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_documents = obj_
            obj_.original_tagname_ = 'underlying_documents'
# end class RightRecordIndivid


class ReinstatementDate(GeneratedsSuper):
    """ReinstatementDate -- В
    о
    с
    с
    т
    а
    н
    о
    в
    л
    е
    н
    и
    е
    п
    р
    а
    в
    а
    н
    а
    о
    с
    н
    о
    в
    а
    н
    и
    и
    с
    у
    д
    е
    б
    н
    о
    г
    о
    а
    к
    т
    а
    prev_registration_date -- Д
    а
    т
    а
    р
    а
    н
    е
    е
    п
    р
    о
    и
    з
    в
    е
    д
    е
    н
    н
    о
    й
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, prev_registration_date=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(prev_registration_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(prev_registration_date, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = prev_registration_date
        self.prev_registration_date = initvalue_
        self.prev_registration_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ReinstatementDate)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ReinstatementDate.subclass:
            return ReinstatementDate.subclass(*args_, **kwargs_)
        else:
            return ReinstatementDate(*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_prev_registration_date(self):
        return self.prev_registration_date
    def set_prev_registration_date(self, prev_registration_date):
        self.prev_registration_date = prev_registration_date
    def has__content(self):
        if (
            self.prev_registration_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ReinstatementDate', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ReinstatementDate')
        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_ == 'ReinstatementDate':
            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_='ReinstatementDate')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ReinstatementDate', 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_='ReinstatementDate'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ReinstatementDate', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.prev_registration_date is not None:
            namespaceprefix_ = self.prev_registration_date_nsprefix_ + ':' if (UseCapturedNS_ and self.prev_registration_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sprev_registration_date>%s</%sprev_registration_date>%s' % (namespaceprefix_ , self.gds_format_datetime(self.prev_registration_date, input_name='prev_registration_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'prev_registration_date':
            sval_ = child_.text
            dval_ = self.gds_parse_datetime(sval_)
            self.prev_registration_date = dval_
            self.prev_registration_date_nsprefix_ = child_.prefix
# end class ReinstatementDate


class OwnerlessRightRecordOut(GeneratedsSuper):
    """OwnerlessRightRecordOut -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    (
    б
    е
    с
    х
    о
    з
    я
    й
    н
    о
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    )
    record_info -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    ownerless_right_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    н
    а
    б
    е
    с
    х
    о
    з
    я
    й
    н
    о
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, ownerless_right_data=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.ownerless_right_data = ownerless_right_data
        self.ownerless_right_data_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OwnerlessRightRecordOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OwnerlessRightRecordOut.subclass:
            return OwnerlessRightRecordOut.subclass(*args_, **kwargs_)
        else:
            return OwnerlessRightRecordOut(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_ownerless_right_data(self):
        return self.ownerless_right_data
    def set_ownerless_right_data(self, ownerless_right_data):
        self.ownerless_right_data = ownerless_right_data
    def has__content(self):
        if (
            self.record_info is not None or
            self.ownerless_right_data is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OwnerlessRightRecordOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OwnerlessRightRecordOut')
        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_ == 'OwnerlessRightRecordOut':
            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_='OwnerlessRightRecordOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OwnerlessRightRecordOut', 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_='OwnerlessRightRecordOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OwnerlessRightRecordOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.ownerless_right_data is not None:
            namespaceprefix_ = self.ownerless_right_data_nsprefix_ + ':' if (UseCapturedNS_ and self.ownerless_right_data_nsprefix_) else ''
            self.ownerless_right_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ownerless_right_data', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RegistrationDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'ownerless_right_data':
            obj_ = OwnerlessRight.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ownerless_right_data = obj_
            obj_.original_tagname_ = 'ownerless_right_data'
# end class OwnerlessRightRecordOut


class OwnerlessRight(GeneratedsSuper):
    """OwnerlessRight -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    н
    а
    б
    е
    с
    х
    о
    з
    я
    й
    н
    о
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    (
    Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    и
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    р
    г
    а
    н
    а
    )
    ownerless_right_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    authority_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    р
    г
    а
    н
    а
    м
    е
    с
    т
    н
    о
    г
    о
    с
    а
    м
    о
    у
    п
    р
    а
    в
    л
    е
    н
    и
    я
    (
    о
    р
    г
    а
    н
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    в
    л
    а
    с
    т
    и
    -
    д
    л
    я
    г
    о
    р
    о
    д
    о
    в
    ф
    е
    д
    е
    р
    а
    л
    ь
    н
    о
    г
    о
    з
    н
    а
    ч
    е
    н
    и
    я
    М
    о
    с
    к
    в
    ы
    ,
    С
    а
    н
    к
    т
    -
    П
    е
    т
    е
    р
    б
    у
    р
    г
    а
    ,
    С
    е
    в
    а
    с
    т
    о
    п
    о
    л
    я
    ),
    п
    р
    е
    д
    с
    т
    а
    в
    и
    в
    ш
    е
    г
    о
    з
    а
    я
    в
    л
    е
    н
    и
    е
    о
    п
    о
    с
    т
    а
    н
    о
    в
    к
    е
    н
    а
    у
    ч
    е
    т
    д
    а
    н
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    в
    к
    а
    ч
    е
    с
    т
    в
    е
    б
    е
    с
    х
    о
    з
    я
    й
    н
    о
    г
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ownerless_right_number=None, authority_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.ownerless_right_number = ownerless_right_number
        self.validate_RecordNumber(self.ownerless_right_number)
        self.ownerless_right_number_nsprefix_ = None
        self.authority_name = authority_name
        self.authority_name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OwnerlessRight)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OwnerlessRight.subclass:
            return OwnerlessRight.subclass(*args_, **kwargs_)
        else:
            return OwnerlessRight(*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_ownerless_right_number(self):
        return self.ownerless_right_number
    def set_ownerless_right_number(self, ownerless_right_number):
        self.ownerless_right_number = ownerless_right_number
    def get_authority_name(self):
        return self.authority_name
    def set_authority_name(self, authority_name):
        self.authority_name = authority_name
    def validate_RecordNumber(self, value):
        result = True
        # Validate type RecordNumber, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.ownerless_right_number is not None or
            self.authority_name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OwnerlessRight', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OwnerlessRight')
        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_ == 'OwnerlessRight':
            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_='OwnerlessRight')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OwnerlessRight', 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_='OwnerlessRight'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OwnerlessRight', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ownerless_right_number is not None:
            namespaceprefix_ = self.ownerless_right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.ownerless_right_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sownerless_right_number>%s</%sownerless_right_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.ownerless_right_number), input_name='ownerless_right_number')), namespaceprefix_ , eol_))
        if self.authority_name is not None:
            namespaceprefix_ = self.authority_name_nsprefix_ + ':' if (UseCapturedNS_ and self.authority_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sauthority_name>%s</%sauthority_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.authority_name), input_name='authority_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ownerless_right_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'ownerless_right_number')
            value_ = self.gds_validate_string(value_, node, 'ownerless_right_number')
            self.ownerless_right_number = value_
            self.ownerless_right_number_nsprefix_ = child_.prefix
            # validate type RecordNumber
            self.validate_RecordNumber(self.ownerless_right_number)
        elif nodeName_ == 'authority_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'authority_name')
            value_ = self.gds_validate_string(value_, node, 'authority_name')
            self.authority_name = value_
            self.authority_name_nsprefix_ = child_.prefix
# end class OwnerlessRight


class Shares(GeneratedsSuper):
    """Shares -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    share -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    share_bal_hectare -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    в
    б
    а
    л
    л
    о
    -
    г
    е
    к
    т
    а
    р
    а
    х
    share_hectare -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    в
    г
    е
    к
    т
    а
    р
    а
    х
    share_unknown -- Н
    е
    у
    к
    а
    з
    а
    н
    р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    н
    а
    о
    б
    щ
    е
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    ,
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    ,
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    о
    в
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    в
    з
    д
    а
    н
    и
    и
    ,
    е
    с
    л
    и
    о
    б
    ъ
    е
    к
    т
    о
    м
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    я
    в
    л
    я
    е
    т
    с
    я
    п
    о
    м
    е
    щ
    е
    н
    и
    е
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    в
    з
    д
    а
    н
    и
    и
    room_owners_share -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    н
    а
    о
    б
    щ
    е
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    о
    в
    к
    о
    м
    н
    а
    т
    в
    ж
    и
    л
    о
    м
    п
    о
    м
    е
    щ
    е
    н
    и
    и
    builder_share -- Д
    о
    л
    я
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    п
    р
    о
    п
    о
    р
    ц
    и
    о
    н
    а
    л
    ь
    н
    а
    р
    а
    з
    м
    е
    р
    у
    о
    б
    щ
    е
    й
    п
    л
    о
    щ
    а
    д
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    ,
    н
    е
    п
    е
    р
    е
    д
    а
    н
    н
    ы
    х
    у
    ч
    а
    с
    т
    н
    и
    к
    а
    м
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    builder_share_with_object -- Д
    о
    л
    я
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    п
    р
    о
    п
    о
    р
    ц
    и
    о
    н
    а
    л
    ь
    н
    а
    р
    а
    з
    м
    е
    р
    у
    о
    б
    щ
    е
    й
    п
    л
    о
    щ
    а
    д
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    ,
    н
    е
    п
    е
    р
    е
    д
    а
    н
    н
    ы
    х
    у
    ч
    а
    с
    т
    н
    и
    к
    а
    м
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    ,
    а
    т
    а
    к
    ж
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, share=None, share_bal_hectare=None, share_hectare=None, share_unknown=None, room_owners_share=None, builder_share=None, builder_share_with_object=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.share = share
        self.share_nsprefix_ = None
        self.share_bal_hectare = share_bal_hectare
        self.share_bal_hectare_nsprefix_ = None
        self.share_hectare = share_hectare
        self.share_hectare_nsprefix_ = None
        self.share_unknown = share_unknown
        self.share_unknown_nsprefix_ = None
        self.room_owners_share = room_owners_share
        self.room_owners_share_nsprefix_ = None
        self.builder_share = builder_share
        self.builder_share_nsprefix_ = None
        self.builder_share_with_object = builder_share_with_object
        self.builder_share_with_object_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Shares)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Shares.subclass:
            return Shares.subclass(*args_, **kwargs_)
        else:
            return Shares(*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_share(self):
        return self.share
    def set_share(self, share):
        self.share = share
    def get_share_bal_hectare(self):
        return self.share_bal_hectare
    def set_share_bal_hectare(self, share_bal_hectare):
        self.share_bal_hectare = share_bal_hectare
    def get_share_hectare(self):
        return self.share_hectare
    def set_share_hectare(self, share_hectare):
        self.share_hectare = share_hectare
    def get_share_unknown(self):
        return self.share_unknown
    def set_share_unknown(self, share_unknown):
        self.share_unknown = share_unknown
    def get_room_owners_share(self):
        return self.room_owners_share
    def set_room_owners_share(self, room_owners_share):
        self.room_owners_share = room_owners_share
    def get_builder_share(self):
        return self.builder_share
    def set_builder_share(self, builder_share):
        self.builder_share = builder_share
    def get_builder_share_with_object(self):
        return self.builder_share_with_object
    def set_builder_share_with_object(self, builder_share_with_object):
        self.builder_share_with_object = builder_share_with_object
    def has__content(self):
        if (
            self.share is not None or
            self.share_bal_hectare is not None or
            self.share_hectare is not None or
            self.share_unknown is not None or
            self.room_owners_share is not None or
            self.builder_share is not None or
            self.builder_share_with_object is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Shares', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Shares')
        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_ == 'Shares':
            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_='Shares')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Shares', 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_='Shares'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Shares', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.share is not None:
            namespaceprefix_ = self.share_nsprefix_ + ':' if (UseCapturedNS_ and self.share_nsprefix_) else ''
            self.share.export(outfile, level, namespaceprefix_, namespacedef_='', name_='share', pretty_print=pretty_print)
        if self.share_bal_hectare is not None:
            namespaceprefix_ = self.share_bal_hectare_nsprefix_ + ':' if (UseCapturedNS_ and self.share_bal_hectare_nsprefix_) else ''
            self.share_bal_hectare.export(outfile, level, namespaceprefix_, namespacedef_='', name_='share_bal_hectare', pretty_print=pretty_print)
        if self.share_hectare is not None:
            namespaceprefix_ = self.share_hectare_nsprefix_ + ':' if (UseCapturedNS_ and self.share_hectare_nsprefix_) else ''
            self.share_hectare.export(outfile, level, namespaceprefix_, namespacedef_='', name_='share_hectare', pretty_print=pretty_print)
        if self.share_unknown is not None:
            namespaceprefix_ = self.share_unknown_nsprefix_ + ':' if (UseCapturedNS_ and self.share_unknown_nsprefix_) else ''
            self.share_unknown.export(outfile, level, namespaceprefix_, namespacedef_='', name_='share_unknown', pretty_print=pretty_print)
        if self.room_owners_share is not None:
            namespaceprefix_ = self.room_owners_share_nsprefix_ + ':' if (UseCapturedNS_ and self.room_owners_share_nsprefix_) else ''
            self.room_owners_share.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_owners_share', pretty_print=pretty_print)
        if self.builder_share is not None:
            namespaceprefix_ = self.builder_share_nsprefix_ + ':' if (UseCapturedNS_ and self.builder_share_nsprefix_) else ''
            self.builder_share.export(outfile, level, namespaceprefix_, namespacedef_='', name_='builder_share', pretty_print=pretty_print)
        if self.builder_share_with_object is not None:
            namespaceprefix_ = self.builder_share_with_object_nsprefix_ + ':' if (UseCapturedNS_ and self.builder_share_with_object_nsprefix_) else ''
            self.builder_share_with_object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='builder_share_with_object', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'share':
            obj_ = Share.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.share = obj_
            obj_.original_tagname_ = 'share'
        elif nodeName_ == 'share_bal_hectare':
            obj_ = ShareBalHectare.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.share_bal_hectare = obj_
            obj_.original_tagname_ = 'share_bal_hectare'
        elif nodeName_ == 'share_hectare':
            obj_ = ShareHectare.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.share_hectare = obj_
            obj_.original_tagname_ = 'share_hectare'
        elif nodeName_ == 'share_unknown':
            obj_ = ShareUnknown.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.share_unknown = obj_
            obj_.original_tagname_ = 'share_unknown'
        elif nodeName_ == 'room_owners_share':
            obj_ = RoomOwnersShare.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_owners_share = obj_
            obj_.original_tagname_ = 'room_owners_share'
        elif nodeName_ == 'builder_share':
            obj_ = BuilderShare.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.builder_share = obj_
            obj_.original_tagname_ = 'builder_share'
        elif nodeName_ == 'builder_share_with_object':
            obj_ = BuilderShareWithObject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.builder_share_with_object = obj_
            obj_.original_tagname_ = 'builder_share_with_object'
# end class Shares


class Share(GeneratedsSuper):
    """Share -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    numerator -- Ч
    и
    с
    л
    и
    т
    е
    л
    ь
    denominator -- З
    н
    а
    м
    е
    н
    а
    т
    е
    л
    ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, numerator=None, denominator=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.numerator = numerator
        self.numerator_nsprefix_ = None
        self.denominator = denominator
        self.denominator_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Share)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Share.subclass:
            return Share.subclass(*args_, **kwargs_)
        else:
            return Share(*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_numerator(self):
        return self.numerator
    def set_numerator(self, numerator):
        self.numerator = numerator
    def get_denominator(self):
        return self.denominator
    def set_denominator(self, denominator):
        self.denominator = denominator
    def has__content(self):
        if (
            self.numerator is not None or
            self.denominator is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Share', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Share')
        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_ == 'Share':
            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_='Share')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Share', 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_='Share'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Share', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.numerator is not None:
            namespaceprefix_ = self.numerator_nsprefix_ + ':' if (UseCapturedNS_ and self.numerator_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumerator>%s</%snumerator>%s' % (namespaceprefix_ , self.gds_format_integer(self.numerator, input_name='numerator'), namespaceprefix_ , eol_))
        if self.denominator is not None:
            namespaceprefix_ = self.denominator_nsprefix_ + ':' if (UseCapturedNS_ and self.denominator_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdenominator>%s</%sdenominator>%s' % (namespaceprefix_ , self.gds_format_integer(self.denominator, input_name='denominator'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'numerator' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'numerator')
            ival_ = self.gds_validate_integer(ival_, node, 'numerator')
            self.numerator = ival_
            self.numerator_nsprefix_ = child_.prefix
        elif nodeName_ == 'denominator' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'denominator')
            ival_ = self.gds_validate_integer(ival_, node, 'denominator')
            self.denominator = ival_
            self.denominator_nsprefix_ = child_.prefix
# end class Share


class ShareBalHectare(GeneratedsSuper):
    """ShareBalHectare -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    в
    б
    а
    л
    л
    о
    -
    г
    е
    к
    т
    а
    р
    а
    х
    bal_hectare -- Б
    а
    л
    л
    о
    -
    г
    е
    к
    т
    а
    р
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, bal_hectare=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.bal_hectare = bal_hectare
        self.validate_PositiveDecimal(self.bal_hectare)
        self.bal_hectare_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ShareBalHectare)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ShareBalHectare.subclass:
            return ShareBalHectare.subclass(*args_, **kwargs_)
        else:
            return ShareBalHectare(*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_bal_hectare(self):
        return self.bal_hectare
    def set_bal_hectare(self, bal_hectare):
        self.bal_hectare = bal_hectare
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.bal_hectare is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ShareBalHectare', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ShareBalHectare')
        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_ == 'ShareBalHectare':
            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_='ShareBalHectare')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ShareBalHectare', 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_='ShareBalHectare'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ShareBalHectare', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.bal_hectare is not None:
            namespaceprefix_ = self.bal_hectare_nsprefix_ + ':' if (UseCapturedNS_ and self.bal_hectare_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbal_hectare>%s</%sbal_hectare>%s' % (namespaceprefix_ , self.gds_format_decimal(self.bal_hectare, input_name='bal_hectare'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'bal_hectare' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'bal_hectare')
            fval_ = self.gds_validate_decimal(fval_, node, 'bal_hectare')
            self.bal_hectare = fval_
            self.bal_hectare_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.bal_hectare)
# end class ShareBalHectare


class ShareHectare(GeneratedsSuper):
    """ShareHectare -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    в
    г
    е
    к
    т
    а
    р
    а
    х
    hectare -- Г
    е
    к
    т
    а
    р
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, hectare=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.hectare = hectare
        self.validate_PositiveDecimal(self.hectare)
        self.hectare_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ShareHectare)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ShareHectare.subclass:
            return ShareHectare.subclass(*args_, **kwargs_)
        else:
            return ShareHectare(*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_hectare(self):
        return self.hectare
    def set_hectare(self, hectare):
        self.hectare = hectare
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.hectare is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ShareHectare', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ShareHectare')
        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_ == 'ShareHectare':
            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_='ShareHectare')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ShareHectare', 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_='ShareHectare'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ShareHectare', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.hectare is not None:
            namespaceprefix_ = self.hectare_nsprefix_ + ':' if (UseCapturedNS_ and self.hectare_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%shectare>%s</%shectare>%s' % (namespaceprefix_ , self.gds_format_decimal(self.hectare, input_name='hectare'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'hectare' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'hectare')
            fval_ = self.gds_validate_decimal(fval_, node, 'hectare')
            self.hectare = fval_
            self.hectare_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.hectare)
# end class ShareHectare


class ShareUnknown(GeneratedsSuper):
    """ShareUnknown -- Н
    е
    у
    к
    а
    з
    а
    н
    р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    н
    а
    о
    б
    щ
    е
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    ,
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    ,
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    о
    в
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    в
    з
    д
    а
    н
    и
    и
    ,
    е
    с
    л
    и
    о
    б
    ъ
    е
    к
    т
    о
    м
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    я
    в
    л
    я
    е
    т
    с
    я
    п
    о
    м
    е
    щ
    е
    н
    и
    е
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    в
    з
    д
    а
    н
    и
    и
    share_description -- Д
    о
    л
    я
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    п
    р
    о
    п
    о
    р
    ц
    и
    о
    н
    а
    л
    ь
    н
    а
    р
    а
    з
    м
    е
    р
    у
    о
    б
    щ
    е
    й
    п
    л
    о
    щ
    а
    д
    и
    proportion_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    д
    л
    я
    р
    а
    с
    ч
    е
    т
    а
    п
    р
    о
    п
    о
    р
    ц
    и
    й
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, share_description=None, proportion_cad_number=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.share_description = share_description
        self.validate_MultiLiner(self.share_description)
        self.share_description_nsprefix_ = None
        self.proportion_cad_number = proportion_cad_number
        self.proportion_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ShareUnknown)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ShareUnknown.subclass:
            return ShareUnknown.subclass(*args_, **kwargs_)
        else:
            return ShareUnknown(*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_share_description(self):
        return self.share_description
    def set_share_description(self, share_description):
        self.share_description = share_description
    def get_proportion_cad_number(self):
        return self.proportion_cad_number
    def set_proportion_cad_number(self, proportion_cad_number):
        self.proportion_cad_number = proportion_cad_number
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.share_description is not None or
            self.proportion_cad_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ShareUnknown', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ShareUnknown')
        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_ == 'ShareUnknown':
            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_='ShareUnknown')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ShareUnknown', 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_='ShareUnknown'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ShareUnknown', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.share_description is not None:
            namespaceprefix_ = self.share_description_nsprefix_ + ':' if (UseCapturedNS_ and self.share_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sshare_description>%s</%sshare_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.share_description), input_name='share_description')), namespaceprefix_ , eol_))
        if self.proportion_cad_number is not None:
            namespaceprefix_ = self.proportion_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.proportion_cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sproportion_cad_number>%s</%sproportion_cad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.proportion_cad_number), input_name='proportion_cad_number')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'share_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'share_description')
            value_ = self.gds_validate_string(value_, node, 'share_description')
            self.share_description = value_
            self.share_description_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.share_description)
        elif nodeName_ == 'proportion_cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'proportion_cad_number')
            value_ = self.gds_validate_string(value_, node, 'proportion_cad_number')
            self.proportion_cad_number = value_
            self.proportion_cad_number_nsprefix_ = child_.prefix
# end class ShareUnknown


class RoomOwnersShare(GeneratedsSuper):
    """RoomOwnersShare -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    н
    а
    о
    б
    щ
    е
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    о
    в
    к
    о
    м
    н
    а
    т
    в
    ж
    и
    л
    о
    м
    п
    о
    м
    е
    щ
    е
    н
    и
    и
    room_owners_share_info -- Р
    а
    з
    м
    е
    р
    д
    о
    л
    и
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    н
    а
    о
    б
    щ
    е
    е
    и
    м
    у
    щ
    е
    с
    т
    в
    о
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    о
    в
    к
    о
    м
    н
    а
    т
    в
    ж
    и
    л
    о
    м
    п
    о
    м
    е
    щ
    е
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, room_owners_share_info=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.room_owners_share_info = room_owners_share_info
        self.validate_MultiLiner(self.room_owners_share_info)
        self.room_owners_share_info_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomOwnersShare)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomOwnersShare.subclass:
            return RoomOwnersShare.subclass(*args_, **kwargs_)
        else:
            return RoomOwnersShare(*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_room_owners_share_info(self):
        return self.room_owners_share_info
    def set_room_owners_share_info(self, room_owners_share_info):
        self.room_owners_share_info = room_owners_share_info
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.room_owners_share_info is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomOwnersShare', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomOwnersShare')
        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_ == 'RoomOwnersShare':
            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_='RoomOwnersShare')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomOwnersShare', 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_='RoomOwnersShare'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomOwnersShare', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.room_owners_share_info is not None:
            namespaceprefix_ = self.room_owners_share_info_nsprefix_ + ':' if (UseCapturedNS_ and self.room_owners_share_info_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sroom_owners_share_info>%s</%sroom_owners_share_info>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.room_owners_share_info), input_name='room_owners_share_info')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'room_owners_share_info':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'room_owners_share_info')
            value_ = self.gds_validate_string(value_, node, 'room_owners_share_info')
            self.room_owners_share_info = value_
            self.room_owners_share_info_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.room_owners_share_info)
# end class RoomOwnersShare


class BuilderShare(GeneratedsSuper):
    """BuilderShare -- Д
    о
    л
    я
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    п
    р
    о
    п
    о
    р
    ц
    и
    о
    н
    а
    л
    ь
    н
    а
    р
    а
    з
    м
    е
    р
    у
    о
    б
    щ
    е
    й
    п
    л
    о
    щ
    а
    д
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    ,
    н
    е
    п
    е
    р
    е
    д
    а
    н
    н
    ы
    х
    у
    ч
    а
    с
    т
    н
    и
    к
    а
    м
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    builder_share_info -- Д
    о
    л
    я
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    п
    р
    о
    п
    о
    р
    ц
    и
    о
    н
    а
    л
    ь
    н
    а
    р
    а
    з
    м
    е
    р
    у
    о
    б
    щ
    е
    й
    п
    л
    о
    щ
    а
    д
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    ,
    н
    е
    п
    е
    р
    е
    д
    а
    н
    н
    ы
    х
    у
    ч
    а
    с
    т
    н
    и
    к
    а
    м
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, builder_share_info=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.builder_share_info = builder_share_info
        self.validate_MultiLiner(self.builder_share_info)
        self.builder_share_info_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BuilderShare)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BuilderShare.subclass:
            return BuilderShare.subclass(*args_, **kwargs_)
        else:
            return BuilderShare(*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_builder_share_info(self):
        return self.builder_share_info
    def set_builder_share_info(self, builder_share_info):
        self.builder_share_info = builder_share_info
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.builder_share_info is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuilderShare', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BuilderShare')
        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_ == 'BuilderShare':
            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_='BuilderShare')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BuilderShare', 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_='BuilderShare'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuilderShare', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.builder_share_info is not None:
            namespaceprefix_ = self.builder_share_info_nsprefix_ + ':' if (UseCapturedNS_ and self.builder_share_info_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbuilder_share_info>%s</%sbuilder_share_info>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.builder_share_info), input_name='builder_share_info')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'builder_share_info':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'builder_share_info')
            value_ = self.gds_validate_string(value_, node, 'builder_share_info')
            self.builder_share_info = value_
            self.builder_share_info_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.builder_share_info)
# end class BuilderShare


class BuilderShareWithObject(GeneratedsSuper):
    """BuilderShareWithObject -- Д
    о
    л
    я
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    п
    р
    о
    п
    о
    р
    ц
    и
    о
    н
    а
    л
    ь
    н
    а
    р
    а
    з
    м
    е
    р
    у
    о
    б
    щ
    е
    й
    п
    л
    о
    щ
    а
    д
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    ,
    н
    е
    п
    е
    р
    е
    д
    а
    н
    н
    ы
    х
    у
    ч
    а
    с
    т
    н
    и
    к
    а
    м
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    ,
    а
    т
    а
    к
    ж
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    builder_share_with_object_info -- Д
    о
    л
    я
    в
    п
    р
    а
    в
    е
    о
    б
    щ
    е
    й
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    п
    р
    о
    п
    о
    р
    ц
    и
    о
    н
    а
    л
    ь
    н
    а
    р
    а
    з
    м
    е
    р
    у
    о
    б
    щ
    е
    й
    п
    л
    о
    щ
    а
    д
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    ,
    н
    е
    п
    е
    р
    е
    д
    а
    н
    н
    ы
    х
    у
    ч
    а
    с
    т
    н
    и
    к
    а
    м
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    ,
    а
    т
    а
    к
    ж
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    info_objects -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    х
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, builder_share_with_object_info=None, info_objects=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.builder_share_with_object_info = builder_share_with_object_info
        self.validate_MultiLiner(self.builder_share_with_object_info)
        self.builder_share_with_object_info_nsprefix_ = None
        self.info_objects = info_objects
        self.info_objects_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BuilderShareWithObject)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BuilderShareWithObject.subclass:
            return BuilderShareWithObject.subclass(*args_, **kwargs_)
        else:
            return BuilderShareWithObject(*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_builder_share_with_object_info(self):
        return self.builder_share_with_object_info
    def set_builder_share_with_object_info(self, builder_share_with_object_info):
        self.builder_share_with_object_info = builder_share_with_object_info
    def get_info_objects(self):
        return self.info_objects
    def set_info_objects(self, info_objects):
        self.info_objects = info_objects
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.builder_share_with_object_info is not None or
            self.info_objects is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuilderShareWithObject', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BuilderShareWithObject')
        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_ == 'BuilderShareWithObject':
            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_='BuilderShareWithObject')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BuilderShareWithObject', 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_='BuilderShareWithObject'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BuilderShareWithObject', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.builder_share_with_object_info is not None:
            namespaceprefix_ = self.builder_share_with_object_info_nsprefix_ + ':' if (UseCapturedNS_ and self.builder_share_with_object_info_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbuilder_share_with_object_info>%s</%sbuilder_share_with_object_info>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.builder_share_with_object_info), input_name='builder_share_with_object_info')), namespaceprefix_ , eol_))
        if self.info_objects is not None:
            namespaceprefix_ = self.info_objects_nsprefix_ + ':' if (UseCapturedNS_ and self.info_objects_nsprefix_) else ''
            self.info_objects.export(outfile, level, namespaceprefix_, namespacedef_='', name_='info_objects', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'builder_share_with_object_info':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'builder_share_with_object_info')
            value_ = self.gds_validate_string(value_, node, 'builder_share_with_object_info')
            self.builder_share_with_object_info = value_
            self.builder_share_with_object_info_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.builder_share_with_object_info)
        elif nodeName_ == 'info_objects':
            obj_ = InfoObjects.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.info_objects = obj_
            obj_.original_tagname_ = 'info_objects'
# end class BuilderShareWithObject


class InfoObjects(GeneratedsSuper):
    """InfoObjects -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    х
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    х
    info_object -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    и
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, info_object=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 info_object is None:
            self.info_object = []
        else:
            self.info_object = info_object
        self.info_object_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, InfoObjects)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if InfoObjects.subclass:
            return InfoObjects.subclass(*args_, **kwargs_)
        else:
            return InfoObjects(*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_info_object(self):
        return self.info_object
    def set_info_object(self, info_object):
        self.info_object = info_object
    def add_info_object(self, value):
        self.info_object.append(value)
    def insert_info_object_at(self, index, value):
        self.info_object.insert(index, value)
    def replace_info_object_at(self, index, value):
        self.info_object[index] = value
    def has__content(self):
        if (
            self.info_object
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='InfoObjects', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('InfoObjects')
        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_ == 'InfoObjects':
            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_='InfoObjects')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='InfoObjects', 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_='InfoObjects'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='InfoObjects', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for info_object_ in self.info_object:
            namespaceprefix_ = self.info_object_nsprefix_ + ':' if (UseCapturedNS_ and self.info_object_nsprefix_) else ''
            info_object_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='info_object', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'info_object':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.info_object.append(obj_)
            obj_.original_tagname_ = 'info_object'
# end class InfoObjects


class RightRecordsLitigationsObjections(GeneratedsSuper):
    """RightRecordsLitigationsObjections -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    о
    б
    ъ
    е
    к
    т
    о
    в
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    right_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_record=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 right_record is None:
            self.right_record = []
        else:
            self.right_record = right_record
        self.right_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightRecordsLitigationsObjections)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightRecordsLitigationsObjections.subclass:
            return RightRecordsLitigationsObjections.subclass(*args_, **kwargs_)
        else:
            return RightRecordsLitigationsObjections(*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_right_record(self):
        return self.right_record
    def set_right_record(self, right_record):
        self.right_record = right_record
    def add_right_record(self, value):
        self.right_record.append(value)
    def insert_right_record_at(self, index, value):
        self.right_record.insert(index, value)
    def replace_right_record_at(self, index, value):
        self.right_record[index] = value
    def has__content(self):
        if (
            self.right_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordsLitigationsObjections', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightRecordsLitigationsObjections')
        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_ == 'RightRecordsLitigationsObjections':
            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_='RightRecordsLitigationsObjections')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightRecordsLitigationsObjections', 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_='RightRecordsLitigationsObjections'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordsLitigationsObjections', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for right_record_ in self.right_record:
            namespaceprefix_ = self.right_record_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_nsprefix_) else ''
            right_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_record':
            obj_ = right_recordType5.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record.append(obj_)
            obj_.original_tagname_ = 'right_record'
# end class RightRecordsLitigationsObjections


class RestrictRecordsMain(GeneratedsSuper):
    """RestrictRecordsMain -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    ,
    с
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    а
    х
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    ,
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    ,
    д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    restrict_record -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restrict_record=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 restrict_record is None:
            self.restrict_record = []
        else:
            self.restrict_record = restrict_record
        self.restrict_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictRecordsMain)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictRecordsMain.subclass:
            return RestrictRecordsMain.subclass(*args_, **kwargs_)
        else:
            return RestrictRecordsMain(*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_restrict_record(self):
        return self.restrict_record
    def set_restrict_record(self, restrict_record):
        self.restrict_record = restrict_record
    def add_restrict_record(self, value):
        self.restrict_record.append(value)
    def insert_restrict_record_at(self, index, value):
        self.restrict_record.insert(index, value)
    def replace_restrict_record_at(self, index, value):
        self.restrict_record[index] = value
    def has__content(self):
        if (
            self.restrict_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordsMain', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictRecordsMain')
        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_ == 'RestrictRecordsMain':
            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_='RestrictRecordsMain')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictRecordsMain', 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_='RestrictRecordsMain'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordsMain', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restrict_record_ in self.restrict_record:
            namespaceprefix_ = self.restrict_record_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_record_nsprefix_) else ''
            restrict_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restrict_record':
            obj_ = RestrictRecordMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_record.append(obj_)
            obj_.original_tagname_ = 'restrict_record'
# end class RestrictRecordsMain


class RestrictRecordMain(GeneratedsSuper):
    """RestrictRecordMain -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    ,
    с
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    а
    х
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    ,
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    ,
    д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    record_info -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    restrictions_encumbrances_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    restrict_parties -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    а
    х
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    ,
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    underlying_documents -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, restrictions_encumbrances_data=None, restrict_parties=None, underlying_documents=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.restrictions_encumbrances_data = restrictions_encumbrances_data
        self.restrictions_encumbrances_data_nsprefix_ = None
        self.restrict_parties = restrict_parties
        self.restrict_parties_nsprefix_ = None
        self.underlying_documents = underlying_documents
        self.underlying_documents_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictRecordMain)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictRecordMain.subclass:
            return RestrictRecordMain.subclass(*args_, **kwargs_)
        else:
            return RestrictRecordMain(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_restrictions_encumbrances_data(self):
        return self.restrictions_encumbrances_data
    def set_restrictions_encumbrances_data(self, restrictions_encumbrances_data):
        self.restrictions_encumbrances_data = restrictions_encumbrances_data
    def get_restrict_parties(self):
        return self.restrict_parties
    def set_restrict_parties(self, restrict_parties):
        self.restrict_parties = restrict_parties
    def get_underlying_documents(self):
        return self.underlying_documents
    def set_underlying_documents(self, underlying_documents):
        self.underlying_documents = underlying_documents
    def has__content(self):
        if (
            self.record_info is not None or
            self.restrictions_encumbrances_data is not None or
            self.restrict_parties is not None or
            self.underlying_documents is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordMain', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictRecordMain')
        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_ == 'RestrictRecordMain':
            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_='RestrictRecordMain')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictRecordMain', 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_='RestrictRecordMain'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordMain', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.restrictions_encumbrances_data is not None:
            namespaceprefix_ = self.restrictions_encumbrances_data_nsprefix_ + ':' if (UseCapturedNS_ and self.restrictions_encumbrances_data_nsprefix_) else ''
            self.restrictions_encumbrances_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrictions_encumbrances_data', pretty_print=pretty_print)
        if self.restrict_parties is not None:
            namespaceprefix_ = self.restrict_parties_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_parties_nsprefix_) else ''
            self.restrict_parties.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_parties', pretty_print=pretty_print)
        if self.underlying_documents is not None:
            namespaceprefix_ = self.underlying_documents_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_documents_nsprefix_) else ''
            self.underlying_documents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_documents', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RegistrationDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'restrictions_encumbrances_data':
            obj_ = RestrictionsEncumbrancesDataLand.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrictions_encumbrances_data = obj_
            obj_.original_tagname_ = 'restrictions_encumbrances_data'
        elif nodeName_ == 'restrict_parties':
            obj_ = RestrictParties.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_parties = obj_
            obj_.original_tagname_ = 'restrict_parties'
        elif nodeName_ == 'underlying_documents':
            obj_ = UnderlyingDocumentsOutAll.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_documents = obj_
            obj_.original_tagname_ = 'underlying_documents'
# end class RestrictRecordMain


class DealRecordsShareHoldings(GeneratedsSuper):
    """DealRecordsShareHoldings -- Д
    о
    г
    о
    в
    о
    р
    ы
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    deal_record -- Д
    о
    г
    о
    в
    о
    р
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, deal_record=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 deal_record is None:
            self.deal_record = []
        else:
            self.deal_record = deal_record
        self.deal_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DealRecordsShareHoldings)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DealRecordsShareHoldings.subclass:
            return DealRecordsShareHoldings.subclass(*args_, **kwargs_)
        else:
            return DealRecordsShareHoldings(*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_deal_record(self):
        return self.deal_record
    def set_deal_record(self, deal_record):
        self.deal_record = deal_record
    def add_deal_record(self, value):
        self.deal_record.append(value)
    def insert_deal_record_at(self, index, value):
        self.deal_record.insert(index, value)
    def replace_deal_record_at(self, index, value):
        self.deal_record[index] = value
    def has__content(self):
        if (
            self.deal_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRecordsShareHoldings', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DealRecordsShareHoldings')
        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_ == 'DealRecordsShareHoldings':
            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_='DealRecordsShareHoldings')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DealRecordsShareHoldings', 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_='DealRecordsShareHoldings'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRecordsShareHoldings', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for deal_record_ in self.deal_record:
            namespaceprefix_ = self.deal_record_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_record_nsprefix_) else ''
            deal_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deal_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'deal_record':
            obj_ = DealRecordShareHoldings.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deal_record.append(obj_)
            obj_.original_tagname_ = 'deal_record'
# end class DealRecordsShareHoldings


class DealRecordShareHoldings(GeneratedsSuper):
    """DealRecordShareHoldings -- Д
    о
    г
    о
    в
    о
    р
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    record_info -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    deal_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    с
    д
    е
    л
    к
    е
    deal_parties -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    а
    х
    ,
    у
    ч
    а
    с
    т
    в
    у
    ю
    щ
    и
    х
    в
    с
    д
    е
    л
    к
    е
    underlying_documents -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    restricting_rights -- О
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    ы
    е
    п
    р
    а
    в
    а
    claim_assignment_marks -- У
    с
    т
    у
    п
    к
    и
    п
    р
    а
    в
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    no_money_rights -- Д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    ы
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    т
    с
    у
    т
    с
    т
    в
    и
    и
    у
    з
    а
    с
    т
    р
    о
    й
    щ
    и
    к
    а
    п
    р
    а
    в
    а
    п
    р
    и
    в
    л
    е
    к
    а
    т
    ь
    д
    е
    н
    е
    ж
    н
    ы
    е
    с
    р
    е
    д
    с
    т
    в
    а
    г
    р
    а
    ж
    д
    а
    н
    ,
    я
    в
    л
    я
    ю
    щ
    и
    х
    с
    я
    у
    ч
    а
    с
    т
    н
    и
    к
    а
    м
    и
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    ,
    н
    а
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    о
    (
    с
    о
    з
    д
    а
    н
    и
    е
    )
    м
    н
    о
    г
    о
    к
    в
    а
    р
    т
    и
    р
    н
    ы
    х
    д
    о
    м
    о
    в
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, deal_data=None, deal_parties=None, underlying_documents=None, restricting_rights=None, claim_assignment_marks=None, no_money_rights=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.deal_data = deal_data
        self.deal_data_nsprefix_ = None
        self.deal_parties = deal_parties
        self.deal_parties_nsprefix_ = None
        self.underlying_documents = underlying_documents
        self.underlying_documents_nsprefix_ = None
        self.restricting_rights = restricting_rights
        self.restricting_rights_nsprefix_ = None
        self.claim_assignment_marks = claim_assignment_marks
        self.claim_assignment_marks_nsprefix_ = None
        self.no_money_rights = no_money_rights
        self.validate_MultiLiner(self.no_money_rights)
        self.no_money_rights_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DealRecordShareHoldings)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DealRecordShareHoldings.subclass:
            return DealRecordShareHoldings.subclass(*args_, **kwargs_)
        else:
            return DealRecordShareHoldings(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_deal_data(self):
        return self.deal_data
    def set_deal_data(self, deal_data):
        self.deal_data = deal_data
    def get_deal_parties(self):
        return self.deal_parties
    def set_deal_parties(self, deal_parties):
        self.deal_parties = deal_parties
    def get_underlying_documents(self):
        return self.underlying_documents
    def set_underlying_documents(self, underlying_documents):
        self.underlying_documents = underlying_documents
    def get_restricting_rights(self):
        return self.restricting_rights
    def set_restricting_rights(self, restricting_rights):
        self.restricting_rights = restricting_rights
    def get_claim_assignment_marks(self):
        return self.claim_assignment_marks
    def set_claim_assignment_marks(self, claim_assignment_marks):
        self.claim_assignment_marks = claim_assignment_marks
    def get_no_money_rights(self):
        return self.no_money_rights
    def set_no_money_rights(self, no_money_rights):
        self.no_money_rights = no_money_rights
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.record_info is not None or
            self.deal_data is not None or
            self.deal_parties is not None or
            self.underlying_documents is not None or
            self.restricting_rights is not None or
            self.claim_assignment_marks is not None or
            self.no_money_rights is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRecordShareHoldings', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DealRecordShareHoldings')
        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_ == 'DealRecordShareHoldings':
            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_='DealRecordShareHoldings')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DealRecordShareHoldings', 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_='DealRecordShareHoldings'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRecordShareHoldings', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.deal_data is not None:
            namespaceprefix_ = self.deal_data_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_data_nsprefix_) else ''
            self.deal_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deal_data', pretty_print=pretty_print)
        if self.deal_parties is not None:
            namespaceprefix_ = self.deal_parties_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_parties_nsprefix_) else ''
            self.deal_parties.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deal_parties', pretty_print=pretty_print)
        if self.underlying_documents is not None:
            namespaceprefix_ = self.underlying_documents_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_documents_nsprefix_) else ''
            self.underlying_documents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_documents', pretty_print=pretty_print)
        if self.restricting_rights is not None:
            namespaceprefix_ = self.restricting_rights_nsprefix_ + ':' if (UseCapturedNS_ and self.restricting_rights_nsprefix_) else ''
            self.restricting_rights.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restricting_rights', pretty_print=pretty_print)
        if self.claim_assignment_marks is not None:
            namespaceprefix_ = self.claim_assignment_marks_nsprefix_ + ':' if (UseCapturedNS_ and self.claim_assignment_marks_nsprefix_) else ''
            self.claim_assignment_marks.export(outfile, level, namespaceprefix_, namespacedef_='', name_='claim_assignment_marks', pretty_print=pretty_print)
        if self.no_money_rights is not None:
            namespaceprefix_ = self.no_money_rights_nsprefix_ + ':' if (UseCapturedNS_ and self.no_money_rights_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sno_money_rights>%s</%sno_money_rights>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.no_money_rights), input_name='no_money_rights')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RegistrationDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'deal_data':
            obj_ = DealDataShareHoldings.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deal_data = obj_
            obj_.original_tagname_ = 'deal_data'
        elif nodeName_ == 'deal_parties':
            obj_ = DealParties.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deal_parties = obj_
            obj_.original_tagname_ = 'deal_parties'
        elif nodeName_ == 'underlying_documents':
            obj_ = UnderlyingDocumentsRequisites.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_documents = obj_
            obj_.original_tagname_ = 'underlying_documents'
        elif nodeName_ == 'restricting_rights':
            obj_ = RestrictingRightsAllNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restricting_rights = obj_
            obj_.original_tagname_ = 'restricting_rights'
        elif nodeName_ == 'claim_assignment_marks':
            obj_ = ClaimAssignmentMarks.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.claim_assignment_marks = obj_
            obj_.original_tagname_ = 'claim_assignment_marks'
        elif nodeName_ == 'no_money_rights':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'no_money_rights')
            value_ = self.gds_validate_string(value_, node, 'no_money_rights')
            self.no_money_rights = value_
            self.no_money_rights_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.no_money_rights)
# end class DealRecordShareHoldings


class DealDataShareHoldings(GeneratedsSuper):
    """DealDataShareHoldings -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    с
    д
    е
    л
    к
    е
    deal_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    с
    д
    е
    л
    к
    и
    deal_type -- В
    и
    д
    с
    д
    е
    л
    к
    и
    -
    д
    о
    г
    о
    в
    о
    р
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    subject -- П
    р
    е
    д
    м
    е
    т
    с
    д
    е
    л
    к
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, deal_number=None, deal_type=None, subject=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.deal_number = deal_number
        self.validate_RecordNumber(self.deal_number)
        self.deal_number_nsprefix_ = None
        self.deal_type = deal_type
        self.deal_type_nsprefix_ = None
        self.subject = subject
        self.subject_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DealDataShareHoldings)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DealDataShareHoldings.subclass:
            return DealDataShareHoldings.subclass(*args_, **kwargs_)
        else:
            return DealDataShareHoldings(*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_deal_number(self):
        return self.deal_number
    def set_deal_number(self, deal_number):
        self.deal_number = deal_number
    def get_deal_type(self):
        return self.deal_type
    def set_deal_type(self, deal_type):
        self.deal_type = deal_type
    def get_subject(self):
        return self.subject
    def set_subject(self, subject):
        self.subject = subject
    def validate_RecordNumber(self, value):
        result = True
        # Validate type RecordNumber, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.deal_number is not None or
            self.deal_type is not None or
            self.subject is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealDataShareHoldings', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DealDataShareHoldings')
        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_ == 'DealDataShareHoldings':
            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_='DealDataShareHoldings')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DealDataShareHoldings', 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_='DealDataShareHoldings'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealDataShareHoldings', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.deal_number is not None:
            namespaceprefix_ = self.deal_number_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdeal_number>%s</%sdeal_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.deal_number), input_name='deal_number')), namespaceprefix_ , eol_))
        if self.deal_type is not None:
            namespaceprefix_ = self.deal_type_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_type_nsprefix_) else ''
            self.deal_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deal_type', pretty_print=pretty_print)
        if self.subject is not None:
            namespaceprefix_ = self.subject_nsprefix_ + ':' if (UseCapturedNS_ and self.subject_nsprefix_) else ''
            self.subject.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subject', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'deal_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'deal_number')
            value_ = self.gds_validate_string(value_, node, 'deal_number')
            self.deal_number = value_
            self.deal_number_nsprefix_ = child_.prefix
            # validate type RecordNumber
            self.validate_RecordNumber(self.deal_number)
        elif nodeName_ == 'deal_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deal_type = obj_
            obj_.original_tagname_ = 'deal_type'
        elif nodeName_ == 'subject':
            obj_ = Subject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.subject = obj_
            obj_.original_tagname_ = 'subject'
# end class DealDataShareHoldings


class ClaimAssignmentMarks(GeneratedsSuper):
    """ClaimAssignmentMarks -- У
    с
    т
    у
    п
    к
    и
    п
    р
    а
    в
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    claim_assignment_mark -- У
    с
    т
    у
    п
    к
    а
    п
    р
    а
    в
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, claim_assignment_mark=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 claim_assignment_mark is None:
            self.claim_assignment_mark = []
        else:
            self.claim_assignment_mark = claim_assignment_mark
        self.claim_assignment_mark_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ClaimAssignmentMarks)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ClaimAssignmentMarks.subclass:
            return ClaimAssignmentMarks.subclass(*args_, **kwargs_)
        else:
            return ClaimAssignmentMarks(*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_claim_assignment_mark(self):
        return self.claim_assignment_mark
    def set_claim_assignment_mark(self, claim_assignment_mark):
        self.claim_assignment_mark = claim_assignment_mark
    def add_claim_assignment_mark(self, value):
        self.claim_assignment_mark.append(value)
    def insert_claim_assignment_mark_at(self, index, value):
        self.claim_assignment_mark.insert(index, value)
    def replace_claim_assignment_mark_at(self, index, value):
        self.claim_assignment_mark[index] = value
    def has__content(self):
        if (
            self.claim_assignment_mark
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimAssignmentMarks', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ClaimAssignmentMarks')
        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_ == 'ClaimAssignmentMarks':
            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_='ClaimAssignmentMarks')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ClaimAssignmentMarks', 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_='ClaimAssignmentMarks'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimAssignmentMarks', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for claim_assignment_mark_ in self.claim_assignment_mark:
            namespaceprefix_ = self.claim_assignment_mark_nsprefix_ + ':' if (UseCapturedNS_ and self.claim_assignment_mark_nsprefix_) else ''
            claim_assignment_mark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='claim_assignment_mark', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'claim_assignment_mark':
            obj_ = ClaimAssignmentMark.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.claim_assignment_mark.append(obj_)
            obj_.original_tagname_ = 'claim_assignment_mark'
# end class ClaimAssignmentMarks


class ClaimAssignmentMark(GeneratedsSuper):
    """ClaimAssignmentMark -- У
    с
    т
    у
    п
    к
    а
    п
    р
    а
    в
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    claim_assignment_record_number -- Н
    о
    м
    е
    р
    з
    а
    п
    и
    с
    и
    о
    с
    д
    е
    л
    к
    е
    п
    о
    у
    с
    т
    у
    п
    к
    е
    п
    р
    а
    в
    т
    р
    е
    б
    о
    в
    а
    н
    и
    й
    description -- О
    п
    и
    с
    а
    н
    и
    е
    с
    в
    е
    д
    е
    н
    и
    й
    о
    б
    у
    с
    т
    у
    п
    к
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, claim_assignment_record_number=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.claim_assignment_record_number = claim_assignment_record_number
        self.claim_assignment_record_number_nsprefix_ = None
        self.description = description
        self.validate_MultiLiner(self.description)
        self.description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ClaimAssignmentMark)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ClaimAssignmentMark.subclass:
            return ClaimAssignmentMark.subclass(*args_, **kwargs_)
        else:
            return ClaimAssignmentMark(*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_claim_assignment_record_number(self):
        return self.claim_assignment_record_number
    def set_claim_assignment_record_number(self, claim_assignment_record_number):
        self.claim_assignment_record_number = claim_assignment_record_number
    def get_description(self):
        return self.description
    def set_description(self, description):
        self.description = description
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.claim_assignment_record_number is not None or
            self.description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimAssignmentMark', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ClaimAssignmentMark')
        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_ == 'ClaimAssignmentMark':
            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_='ClaimAssignmentMark')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ClaimAssignmentMark', 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_='ClaimAssignmentMark'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimAssignmentMark', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.claim_assignment_record_number is not None:
            namespaceprefix_ = self.claim_assignment_record_number_nsprefix_ + ':' if (UseCapturedNS_ and self.claim_assignment_record_number_nsprefix_) else ''
            self.claim_assignment_record_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='claim_assignment_record_number', pretty_print=pretty_print)
        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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'claim_assignment_record_number':
            obj_ = DealRecordNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.claim_assignment_record_number = obj_
            obj_.original_tagname_ = 'claim_assignment_record_number'
        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
            # validate type MultiLiner
            self.validate_MultiLiner(self.description)
# end class ClaimAssignmentMark


class ObjectAndWithdrawalState(GeneratedsSuper):
    """ObjectAndWithdrawalState -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    т
    .
    ч
    .
    с
    в
    е
    д
    е
    н
    и
    я
    о
    н
    а
    л
    и
    ч
    и
    и
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    )
    common_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    date_removed_cad_account -- С
    в
    е
    д
    е
    н
    и
    я
    о
    н
    а
    л
    и
    ч
    и
    и
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    (c
    р
    о
    к
    с
    н
    я
    т
    и
    я
    с
    Г
    К
    У
    3
    г
    о
    д
    а
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, common_data=None, date_removed_cad_account=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.common_data = common_data
        self.common_data_nsprefix_ = None
        self.date_removed_cad_account = date_removed_cad_account
        self.date_removed_cad_account_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ObjectAndWithdrawalState)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ObjectAndWithdrawalState.subclass:
            return ObjectAndWithdrawalState.subclass(*args_, **kwargs_)
        else:
            return ObjectAndWithdrawalState(*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_common_data(self):
        return self.common_data
    def set_common_data(self, common_data):
        self.common_data = common_data
    def get_date_removed_cad_account(self):
        return self.date_removed_cad_account
    def set_date_removed_cad_account(self, date_removed_cad_account):
        self.date_removed_cad_account = date_removed_cad_account
    def has__content(self):
        if (
            self.common_data is not None or
            self.date_removed_cad_account is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectAndWithdrawalState', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ObjectAndWithdrawalState')
        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_ == 'ObjectAndWithdrawalState':
            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_='ObjectAndWithdrawalState')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ObjectAndWithdrawalState', 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_='ObjectAndWithdrawalState'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ObjectAndWithdrawalState', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.common_data is not None:
            namespaceprefix_ = self.common_data_nsprefix_ + ':' if (UseCapturedNS_ and self.common_data_nsprefix_) else ''
            self.common_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='common_data', pretty_print=pretty_print)
        if self.date_removed_cad_account is not None:
            namespaceprefix_ = self.date_removed_cad_account_nsprefix_ + ':' if (UseCapturedNS_ and self.date_removed_cad_account_nsprefix_) else ''
            self.date_removed_cad_account.export(outfile, level, namespaceprefix_, namespacedef_='', name_='date_removed_cad_account', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'common_data':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.common_data = obj_
            obj_.original_tagname_ = 'common_data'
        elif nodeName_ == 'date_removed_cad_account':
            obj_ = DateRemovedCadAccount.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.date_removed_cad_account = obj_
            obj_.original_tagname_ = 'date_removed_cad_account'
# end class ObjectAndWithdrawalState


class ApartmentBuilding(GeneratedsSuper):
    """ApartmentBuilding -- С
    в
    е
    д
    е
    н
    и
    я
    о
    с
    о
    з
    д
    а
    н
    и
    и
    (
    э
    к
    с
    п
    л
    у
    а
    т
    а
    ц
    и
    и
    )
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    н
    а
    е
    м
    н
    о
    г
    о
    д
    о
    м
    а
    basis_hired_house -- О
    с
    н
    о
    в
    а
    н
    и
    е
    с
    о
    з
    д
    а
    н
    и
    я
    н
    а
    е
    м
    н
    о
    г
    о
    д
    о
    м
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, basis_hired_house=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.basis_hired_house = basis_hired_house
        self.basis_hired_house_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ApartmentBuilding)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ApartmentBuilding.subclass:
            return ApartmentBuilding.subclass(*args_, **kwargs_)
        else:
            return ApartmentBuilding(*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_basis_hired_house(self):
        return self.basis_hired_house
    def set_basis_hired_house(self, basis_hired_house):
        self.basis_hired_house = basis_hired_house
    def has__content(self):
        if (
            self.basis_hired_house is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ApartmentBuilding', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ApartmentBuilding')
        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_ == 'ApartmentBuilding':
            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_='ApartmentBuilding')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ApartmentBuilding', 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_='ApartmentBuilding'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ApartmentBuilding', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.basis_hired_house is not None:
            namespaceprefix_ = self.basis_hired_house_nsprefix_ + ':' if (UseCapturedNS_ and self.basis_hired_house_nsprefix_) else ''
            self.basis_hired_house.export(outfile, level, namespaceprefix_, namespacedef_='', name_='basis_hired_house', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'basis_hired_house':
            obj_ = BasisHiredHouse.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.basis_hired_house = obj_
            obj_.original_tagname_ = 'basis_hired_house'
# end class ApartmentBuilding


class LandRecordApartmentBuilding(GeneratedsSuper):
    """LandRecordApartmentBuilding -- С
    в
    е
    д
    е
    н
    и
    я
    о
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    а
    х
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    и
    с
    в
    е
    д
    е
    н
    и
    я
    о
    с
    о
    з
    д
    а
    н
    и
    и
    (
    э
    к
    с
    п
    л
    у
    а
    т
    а
    ц
    и
    и
    )
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    н
    а
    е
    м
    н
    о
    г
    о
    д
    о
    м
    а
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    т
    .
    ч
    .
    с
    в
    е
    д
    е
    н
    и
    я
    о
    н
    а
    л
    и
    ч
    и
    и
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    )
    apartment_building -- С
    в
    е
    д
    е
    н
    и
    я
    о
    с
    о
    з
    д
    а
    н
    и
    и
    (
    э
    к
    с
    п
    л
    у
    а
    т
    а
    ц
    и
    и
    )
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    н
    а
    е
    м
    н
    о
    г
    о
    д
    о
    м
    а
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, apartment_building=None, params=None, address_location=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.object = object
        self.object_nsprefix_ = None
        self.apartment_building = apartment_building
        self.apartment_building_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LandRecordApartmentBuilding)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LandRecordApartmentBuilding.subclass:
            return LandRecordApartmentBuilding.subclass(*args_, **kwargs_)
        else:
            return LandRecordApartmentBuilding(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_apartment_building(self):
        return self.apartment_building
    def set_apartment_building(self, apartment_building):
        self.apartment_building = apartment_building
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def has__content(self):
        if (
            self.object is not None or
            self.apartment_building is not None or
            self.params is not None or
            self.address_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandRecordApartmentBuilding', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LandRecordApartmentBuilding')
        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_ == 'LandRecordApartmentBuilding':
            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_='LandRecordApartmentBuilding')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LandRecordApartmentBuilding', 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_='LandRecordApartmentBuilding'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandRecordApartmentBuilding', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.apartment_building is not None:
            namespaceprefix_ = self.apartment_building_nsprefix_ + ':' if (UseCapturedNS_ and self.apartment_building_nsprefix_) else ''
            self.apartment_building.export(outfile, level, namespaceprefix_, namespacedef_='', name_='apartment_building', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectAndWithdrawalState.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'apartment_building':
            obj_ = ApartmentBuilding.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.apartment_building = obj_
            obj_.original_tagname_ = 'apartment_building'
        elif nodeName_ == 'params':
            obj_ = ParamsLandCategoryUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationLand.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
# end class LandRecordApartmentBuilding


class PersonalParticipations(GeneratedsSuper):
    """PersonalParticipations -- Л
    и
    ч
    н
    о
    е
    у
    ч
    а
    с
    т
    и
    е
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    personal_participation -- Л
    и
    ч
    н
    о
    е
    у
    ч
    а
    с
    т
    и
    е
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, personal_participation=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 personal_participation is None:
            self.personal_participation = []
        else:
            self.personal_participation = personal_participation
        self.personal_participation_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PersonalParticipations)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PersonalParticipations.subclass:
            return PersonalParticipations.subclass(*args_, **kwargs_)
        else:
            return PersonalParticipations(*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_personal_participation(self):
        return self.personal_participation
    def set_personal_participation(self, personal_participation):
        self.personal_participation = personal_participation
    def add_personal_participation(self, value):
        self.personal_participation.append(value)
    def insert_personal_participation_at(self, index, value):
        self.personal_participation.insert(index, value)
    def replace_personal_participation_at(self, index, value):
        self.personal_participation[index] = value
    def has__content(self):
        if (
            self.personal_participation
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PersonalParticipations', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PersonalParticipations')
        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_ == 'PersonalParticipations':
            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_='PersonalParticipations')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PersonalParticipations', 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_='PersonalParticipations'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PersonalParticipations', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for personal_participation_ in self.personal_participation:
            namespaceprefix_ = self.personal_participation_nsprefix_ + ':' if (UseCapturedNS_ and self.personal_participation_nsprefix_) else ''
            personal_participation_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='personal_participation', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'personal_participation':
            obj_ = personal_participationType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.personal_participation.append(obj_)
            obj_.original_tagname_ = 'personal_participation'
# end class PersonalParticipations


class ClaimRecordsOutType(GeneratedsSuper):
    """ClaimRecordsOutType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    я
    х
    claim_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, claim_record=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 claim_record is None:
            self.claim_record = []
        else:
            self.claim_record = claim_record
        self.claim_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ClaimRecordsOutType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ClaimRecordsOutType.subclass:
            return ClaimRecordsOutType.subclass(*args_, **kwargs_)
        else:
            return ClaimRecordsOutType(*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_claim_record(self):
        return self.claim_record
    def set_claim_record(self, claim_record):
        self.claim_record = claim_record
    def add_claim_record(self, value):
        self.claim_record.append(value)
    def insert_claim_record_at(self, index, value):
        self.claim_record.insert(index, value)
    def replace_claim_record_at(self, index, value):
        self.claim_record[index] = value
    def has__content(self):
        if (
            self.claim_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimRecordsOutType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ClaimRecordsOutType')
        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_ == 'ClaimRecordsOutType':
            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_='ClaimRecordsOutType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ClaimRecordsOutType', 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_='ClaimRecordsOutType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimRecordsOutType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for claim_record_ in self.claim_record:
            namespaceprefix_ = self.claim_record_nsprefix_ + ':' if (UseCapturedNS_ and self.claim_record_nsprefix_) else ''
            claim_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='claim_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'claim_record':
            obj_ = claim_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.claim_record.append(obj_)
            obj_.original_tagname_ = 'claim_record'
# end class ClaimRecordsOutType


class ClaimRecordsOut(GeneratedsSuper):
    """ClaimRecordsOut -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    я
    х
    claim_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, claim_record=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 claim_record is None:
            self.claim_record = []
        else:
            self.claim_record = claim_record
        self.claim_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ClaimRecordsOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ClaimRecordsOut.subclass:
            return ClaimRecordsOut.subclass(*args_, **kwargs_)
        else:
            return ClaimRecordsOut(*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_claim_record(self):
        return self.claim_record
    def set_claim_record(self, claim_record):
        self.claim_record = claim_record
    def add_claim_record(self, value):
        self.claim_record.append(value)
    def insert_claim_record_at(self, index, value):
        self.claim_record.insert(index, value)
    def replace_claim_record_at(self, index, value):
        self.claim_record[index] = value
    def has__content(self):
        if (
            self.claim_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimRecordsOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ClaimRecordsOut')
        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_ == 'ClaimRecordsOut':
            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_='ClaimRecordsOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ClaimRecordsOut', 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_='ClaimRecordsOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimRecordsOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for claim_record_ in self.claim_record:
            namespaceprefix_ = self.claim_record_nsprefix_ + ':' if (UseCapturedNS_ and self.claim_record_nsprefix_) else ''
            claim_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='claim_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'claim_record':
            obj_ = ClaimRecordOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.claim_record.append(obj_)
            obj_.original_tagname_ = 'claim_record'
# end class ClaimRecordsOut


class ClaimRecordOut(GeneratedsSuper):
    """ClaimRecordOut -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    и
    claim_data -- П
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, claim_data=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.claim_data = claim_data
        self.claim_data_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ClaimRecordOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ClaimRecordOut.subclass:
            return ClaimRecordOut.subclass(*args_, **kwargs_)
        else:
            return ClaimRecordOut(*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_claim_data(self):
        return self.claim_data
    def set_claim_data(self, claim_data):
        self.claim_data = claim_data
    def has__content(self):
        if (
            self.claim_data is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimRecordOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ClaimRecordOut')
        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_ == 'ClaimRecordOut':
            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_='ClaimRecordOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ClaimRecordOut', 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_='ClaimRecordOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimRecordOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.claim_data is not None:
            namespaceprefix_ = self.claim_data_nsprefix_ + ':' if (UseCapturedNS_ and self.claim_data_nsprefix_) else ''
            self.claim_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='claim_data', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'claim_data':
            obj_ = ClaimDataOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.claim_data = obj_
            obj_.original_tagname_ = 'claim_data'
# end class ClaimRecordOut


class ClaimDataOut(GeneratedsSuper):
    """ClaimDataOut -- В
    и
    д
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    о
    н
    н
    о
    -
    у
    ч
    е
    т
    н
    о
    г
    о
    д
    е
    й
    с
    т
    в
    и
    я
    и
    с
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    т
    м
    е
    т
    к
    и
    п
    р
    и
    в
    о
    з
    н
    и
    к
    н
    о
    в
    е
    н
    и
    и
    urd_type -- В
    и
    д
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    о
    н
    н
    о
    -
    у
    ч
    е
    т
    н
    о
    г
    о
    д
    е
    й
    с
    т
    в
    и
    я
    mark_content -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    т
    м
    е
    т
    к
    и
    п
    р
    и
    в
    о
    з
    н
    и
    к
    н
    о
    в
    е
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, urd_type=None, mark_content=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.urd_type = urd_type
        self.urd_type_nsprefix_ = None
        self.mark_content = mark_content
        self.mark_content_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ClaimDataOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ClaimDataOut.subclass:
            return ClaimDataOut.subclass(*args_, **kwargs_)
        else:
            return ClaimDataOut(*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_urd_type(self):
        return self.urd_type
    def set_urd_type(self, urd_type):
        self.urd_type = urd_type
    def get_mark_content(self):
        return self.mark_content
    def set_mark_content(self, mark_content):
        self.mark_content = mark_content
    def has__content(self):
        if (
            self.urd_type is not None or
            self.mark_content is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimDataOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ClaimDataOut')
        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_ == 'ClaimDataOut':
            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_='ClaimDataOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ClaimDataOut', 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_='ClaimDataOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimDataOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.urd_type is not None:
            namespaceprefix_ = self.urd_type_nsprefix_ + ':' if (UseCapturedNS_ and self.urd_type_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%surd_type>%s</%surd_type>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.urd_type), input_name='urd_type')), namespaceprefix_ , eol_))
        if self.mark_content is not None:
            namespaceprefix_ = self.mark_content_nsprefix_ + ':' if (UseCapturedNS_ and self.mark_content_nsprefix_) else ''
            self.mark_content.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mark_content', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'urd_type':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'urd_type')
            value_ = self.gds_validate_string(value_, node, 'urd_type')
            self.urd_type = value_
            self.urd_type_nsprefix_ = child_.prefix
        elif nodeName_ == 'mark_content':
            obj_ = MarkContent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.mark_content = obj_
            obj_.original_tagname_ = 'mark_content'
# end class ClaimDataOut


class ClaimRecordsOutAll(GeneratedsSuper):
    """ClaimRecordsOutAll -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    я
    х
    claim_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, claim_record=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 claim_record is None:
            self.claim_record = []
        else:
            self.claim_record = claim_record
        self.claim_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ClaimRecordsOutAll)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ClaimRecordsOutAll.subclass:
            return ClaimRecordsOutAll.subclass(*args_, **kwargs_)
        else:
            return ClaimRecordsOutAll(*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_claim_record(self):
        return self.claim_record
    def set_claim_record(self, claim_record):
        self.claim_record = claim_record
    def add_claim_record(self, value):
        self.claim_record.append(value)
    def insert_claim_record_at(self, index, value):
        self.claim_record.insert(index, value)
    def replace_claim_record_at(self, index, value):
        self.claim_record[index] = value
    def has__content(self):
        if (
            self.claim_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimRecordsOutAll', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ClaimRecordsOutAll')
        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_ == 'ClaimRecordsOutAll':
            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_='ClaimRecordsOutAll')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ClaimRecordsOutAll', 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_='ClaimRecordsOutAll'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimRecordsOutAll', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for claim_record_ in self.claim_record:
            namespaceprefix_ = self.claim_record_nsprefix_ + ':' if (UseCapturedNS_ and self.claim_record_nsprefix_) else ''
            claim_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='claim_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'claim_record':
            obj_ = claim_recordType6.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.claim_record.append(obj_)
            obj_.original_tagname_ = 'claim_record'
# end class ClaimRecordsOutAll


class ClaimDataOutAll(GeneratedsSuper):
    """ClaimDataOutAll -- П
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    е
    urd_type -- В
    и
    д
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    о
    н
    н
    о
    -
    у
    ч
    е
    т
    н
    о
    г
    о
    д
    е
    й
    с
    т
    в
    и
    я
    cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    и
    м
    у
    щ
    е
    с
    т
    в
    а
    right_record_numbers -- Н
    о
    м
    е
    р
    а
    р
    е
    е
    с
    т
    р
    о
    в
    ы
    х
    з
    а
    п
    и
    с
    е
    й
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    е
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    я
    mark_content -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    т
    м
    е
    т
    к
    и
    п
    р
    и
    в
    о
    з
    н
    и
    к
    н
    о
    в
    е
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, urd_type=None, cad_number=None, right_record_numbers=None, mark_content=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.urd_type = urd_type
        self.urd_type_nsprefix_ = None
        self.cad_number = cad_number
        self.cad_number_nsprefix_ = None
        self.right_record_numbers = right_record_numbers
        self.right_record_numbers_nsprefix_ = None
        self.mark_content = mark_content
        self.mark_content_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ClaimDataOutAll)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ClaimDataOutAll.subclass:
            return ClaimDataOutAll.subclass(*args_, **kwargs_)
        else:
            return ClaimDataOutAll(*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_urd_type(self):
        return self.urd_type
    def set_urd_type(self, urd_type):
        self.urd_type = urd_type
    def get_cad_number(self):
        return self.cad_number
    def set_cad_number(self, cad_number):
        self.cad_number = cad_number
    def get_right_record_numbers(self):
        return self.right_record_numbers
    def set_right_record_numbers(self, right_record_numbers):
        self.right_record_numbers = right_record_numbers
    def get_mark_content(self):
        return self.mark_content
    def set_mark_content(self, mark_content):
        self.mark_content = mark_content
    def has__content(self):
        if (
            self.urd_type is not None or
            self.cad_number is not None or
            self.right_record_numbers is not None or
            self.mark_content is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimDataOutAll', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ClaimDataOutAll')
        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_ == 'ClaimDataOutAll':
            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_='ClaimDataOutAll')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ClaimDataOutAll', 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_='ClaimDataOutAll'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ClaimDataOutAll', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.urd_type is not None:
            namespaceprefix_ = self.urd_type_nsprefix_ + ':' if (UseCapturedNS_ and self.urd_type_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%surd_type>%s</%surd_type>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.urd_type), input_name='urd_type')), namespaceprefix_ , eol_))
        if self.cad_number is not None:
            namespaceprefix_ = self.cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scad_number>%s</%scad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cad_number), input_name='cad_number')), namespaceprefix_ , eol_))
        if self.right_record_numbers is not None:
            namespaceprefix_ = self.right_record_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_numbers_nsprefix_) else ''
            self.right_record_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record_numbers', pretty_print=pretty_print)
        if self.mark_content is not None:
            namespaceprefix_ = self.mark_content_nsprefix_ + ':' if (UseCapturedNS_ and self.mark_content_nsprefix_) else ''
            self.mark_content.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mark_content', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'urd_type':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'urd_type')
            value_ = self.gds_validate_string(value_, node, 'urd_type')
            self.urd_type = value_
            self.urd_type_nsprefix_ = child_.prefix
        elif nodeName_ == 'cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cad_number')
            value_ = self.gds_validate_string(value_, node, 'cad_number')
            self.cad_number = value_
            self.cad_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'right_record_numbers':
            obj_ = right_record_numbersType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record_numbers = obj_
            obj_.original_tagname_ = 'right_record_numbers'
        elif nodeName_ == 'mark_content':
            obj_ = MarkContent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.mark_content = obj_
            obj_.original_tagname_ = 'mark_content'
# end class ClaimDataOutAll


class Objections(GeneratedsSuper):
    """Objections -- С
    в
    е
    д
    е
    н
    и
    я
    о
    в
    о
    з
    р
    а
    ж
    е
    н
    и
    и
    в
    о
    т
    н
    о
    ш
    е
    н
    и
    и
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    п
    р
    а
    в
    а
    objection -- В
    о
    з
    р
    а
    ж
    е
    н
    и
    е
    в
    о
    т
    н
    о
    ш
    е
    н
    и
    и
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, objection=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 objection is None:
            self.objection = []
        else:
            self.objection = objection
        self.objection_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Objections)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Objections.subclass:
            return Objections.subclass(*args_, **kwargs_)
        else:
            return Objections(*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_objection(self):
        return self.objection
    def set_objection(self, objection):
        self.objection = objection
    def add_objection(self, value):
        self.objection.append(value)
    def insert_objection_at(self, index, value):
        self.objection.insert(index, value)
    def replace_objection_at(self, index, value):
        self.objection[index] = value
    def has__content(self):
        if (
            self.objection
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Objections', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Objections')
        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_ == 'Objections':
            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_='Objections')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Objections', 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_='Objections'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Objections', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for objection_ in self.objection:
            namespaceprefix_ = self.objection_nsprefix_ + ':' if (UseCapturedNS_ and self.objection_nsprefix_) else ''
            objection_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='objection', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'objection':
            obj_ = objectionType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.objection.append(obj_)
            obj_.original_tagname_ = 'objection'
# end class Objections


class Litigations(GeneratedsSuper):
    """Litigations -- Н
    а
    л
    и
    ч
    и
    е
    с
    у
    д
    е
    б
    н
    о
    г
    о
    с
    п
    о
    р
    а
    (
    з
    а
    я
    в
    л
    е
    н
    н
    ы
    е
    п
    р
    а
    в
    а
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    )
    litigation -- Н
    а
    л
    и
    ч
    и
    е
    с
    у
    д
    е
    б
    н
    о
    г
    о
    с
    п
    о
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, litigation=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 litigation is None:
            self.litigation = []
        else:
            self.litigation = litigation
        self.litigation_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Litigations)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Litigations.subclass:
            return Litigations.subclass(*args_, **kwargs_)
        else:
            return Litigations(*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_litigation(self):
        return self.litigation
    def set_litigation(self, litigation):
        self.litigation = litigation
    def add_litigation(self, value):
        self.litigation.append(value)
    def insert_litigation_at(self, index, value):
        self.litigation.insert(index, value)
    def replace_litigation_at(self, index, value):
        self.litigation[index] = value
    def has__content(self):
        if (
            self.litigation
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Litigations', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Litigations')
        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_ == 'Litigations':
            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_='Litigations')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Litigations', 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_='Litigations'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Litigations', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for litigation_ in self.litigation:
            namespaceprefix_ = self.litigation_nsprefix_ + ':' if (UseCapturedNS_ and self.litigation_nsprefix_) else ''
            litigation_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='litigation', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'litigation':
            obj_ = litigationType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.litigation.append(obj_)
            obj_.original_tagname_ = 'litigation'
# end class Litigations


class LitigationsContent(GeneratedsSuper):
    """LitigationsContent -- З
    а
    я
    в
    л
    е
    н
    н
    ы
    е
    в
    с
    у
    д
    е
    б
    н
    о
    м
    п
    о
    р
    я
    д
    к
    е
    п
    р
    а
    в
    а
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    (
    С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    т
    м
    е
    т
    к
    и
    п
    р
    и
    в
    о
    з
    н
    и
    к
    н
    о
    в
    е
    н
    и
    и
    )
    litigation -- З
    а
    я
    в
    л
    е
    н
    н
    о
    е
    в
    с
    у
    д
    е
    б
    н
    о
    м
    п
    о
    р
    я
    д
    к
    е
    п
    р
    а
    в
    о
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, litigation=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 litigation is None:
            self.litigation = []
        else:
            self.litigation = litigation
        self.litigation_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LitigationsContent)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LitigationsContent.subclass:
            return LitigationsContent.subclass(*args_, **kwargs_)
        else:
            return LitigationsContent(*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_litigation(self):
        return self.litigation
    def set_litigation(self, litigation):
        self.litigation = litigation
    def add_litigation(self, value):
        self.litigation.append(value)
    def insert_litigation_at(self, index, value):
        self.litigation.insert(index, value)
    def replace_litigation_at(self, index, value):
        self.litigation[index] = value
    def has__content(self):
        if (
            self.litigation
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LitigationsContent', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LitigationsContent')
        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_ == 'LitigationsContent':
            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_='LitigationsContent')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LitigationsContent', 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_='LitigationsContent'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LitigationsContent', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for litigation_ in self.litigation:
            namespaceprefix_ = self.litigation_nsprefix_ + ':' if (UseCapturedNS_ and self.litigation_nsprefix_) else ''
            litigation_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='litigation', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'litigation':
            obj_ = litigationType7.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.litigation.append(obj_)
            obj_.original_tagname_ = 'litigation'
# end class LitigationsContent


class StateExpropriation(GeneratedsSuper):
    """StateExpropriation -- И
    з
    ъ
    я
    т
    и
    е
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    л
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    expropriation_info -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    е
    ш
    е
    н
    и
    и
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    и
    (
    и
    л
    и
    )
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    н
    а
    н
    е
    м
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    л
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, expropriation_info=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.expropriation_info = expropriation_info
        self.expropriation_info_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, StateExpropriation)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if StateExpropriation.subclass:
            return StateExpropriation.subclass(*args_, **kwargs_)
        else:
            return StateExpropriation(*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_expropriation_info(self):
        return self.expropriation_info
    def set_expropriation_info(self, expropriation_info):
        self.expropriation_info = expropriation_info
    def has__content(self):
        if (
            self.expropriation_info is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='StateExpropriation', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('StateExpropriation')
        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_ == 'StateExpropriation':
            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_='StateExpropriation')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='StateExpropriation', 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_='StateExpropriation'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='StateExpropriation', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.expropriation_info is not None:
            namespaceprefix_ = self.expropriation_info_nsprefix_ + ':' if (UseCapturedNS_ and self.expropriation_info_nsprefix_) else ''
            self.expropriation_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='expropriation_info', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'expropriation_info':
            obj_ = ExpropriationInfo.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.expropriation_info = obj_
            obj_.original_tagname_ = 'expropriation_info'
# end class StateExpropriation


class ExpropriationInfo(GeneratedsSuper):
    """ExpropriationInfo -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    е
    ш
    е
    н
    и
    и
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    и
    (
    и
    л
    и
    )
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    н
    а
    н
    е
    м
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    л
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    expropriation_info_type -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    е
    ш
    е
    н
    и
    и
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    и
    (
    и
    л
    и
    )
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    н
    а
    н
    е
    м
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    л
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    origin_content -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    т
    м
    е
    т
    к
    и
    п
    р
    и
    в
    о
    з
    н
    и
    к
    н
    о
    в
    е
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, expropriation_info_type=None, origin_content=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.expropriation_info_type = expropriation_info_type
        self.expropriation_info_type_nsprefix_ = None
        self.origin_content = origin_content
        self.validate_MultiLiner(self.origin_content)
        self.origin_content_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ExpropriationInfo)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ExpropriationInfo.subclass:
            return ExpropriationInfo.subclass(*args_, **kwargs_)
        else:
            return ExpropriationInfo(*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_expropriation_info_type(self):
        return self.expropriation_info_type
    def set_expropriation_info_type(self, expropriation_info_type):
        self.expropriation_info_type = expropriation_info_type
    def get_origin_content(self):
        return self.origin_content
    def set_origin_content(self, origin_content):
        self.origin_content = origin_content
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.expropriation_info_type is not None or
            self.origin_content is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ExpropriationInfo', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ExpropriationInfo')
        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_ == 'ExpropriationInfo':
            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_='ExpropriationInfo')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ExpropriationInfo', 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_='ExpropriationInfo'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ExpropriationInfo', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.expropriation_info_type is not None:
            namespaceprefix_ = self.expropriation_info_type_nsprefix_ + ':' if (UseCapturedNS_ and self.expropriation_info_type_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sexpropriation_info_type>%s</%sexpropriation_info_type>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.expropriation_info_type), input_name='expropriation_info_type')), namespaceprefix_ , eol_))
        if self.origin_content is not None:
            namespaceprefix_ = self.origin_content_nsprefix_ + ':' if (UseCapturedNS_ and self.origin_content_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sorigin_content>%s</%sorigin_content>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.origin_content), input_name='origin_content')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'expropriation_info_type':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'expropriation_info_type')
            value_ = self.gds_validate_string(value_, node, 'expropriation_info_type')
            self.expropriation_info_type = value_
            self.expropriation_info_type_nsprefix_ = child_.prefix
        elif nodeName_ == 'origin_content':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'origin_content')
            value_ = self.gds_validate_string(value_, node, 'origin_content')
            self.origin_content = value_
            self.origin_content_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.origin_content)
# end class ExpropriationInfo


class Contractors(GeneratedsSuper):
    """Contractors -- С
    т
    о
    р
    о
    н
    ы
    д
    о
    г
    о
    в
    о
    р
    а
    contractor -- С
    т
    о
    р
    о
    н
    а
    д
    о
    г
    о
    в
    о
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, contractor=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 contractor is None:
            self.contractor = []
        else:
            self.contractor = contractor
        self.contractor_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Contractors)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Contractors.subclass:
            return Contractors.subclass(*args_, **kwargs_)
        else:
            return Contractors(*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_contractor(self):
        return self.contractor
    def set_contractor(self, contractor):
        self.contractor = contractor
    def add_contractor(self, value):
        self.contractor.append(value)
    def insert_contractor_at(self, index, value):
        self.contractor.insert(index, value)
    def replace_contractor_at(self, index, value):
        self.contractor[index] = value
    def has__content(self):
        if (
            self.contractor
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Contractors', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Contractors')
        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_ == 'Contractors':
            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_='Contractors')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Contractors', 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_='Contractors'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Contractors', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for contractor_ in self.contractor:
            namespaceprefix_ = self.contractor_nsprefix_ + ':' if (UseCapturedNS_ and self.contractor_nsprefix_) else ''
            contractor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contractor', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'contractor':
            obj_ = Name.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contractor.append(obj_)
            obj_.original_tagname_ = 'contractor'
# end class Contractors


class DealRecordsType(GeneratedsSuper):
    """DealRecordsType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    с
    д
    е
    л
    к
    а
    х
    ,
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    ы
    х
    б
    е
    з
    н
    е
    о
    б
    х
    о
    д
    и
    м
    о
    г
    о
    в
    с
    и
    л
    у
    з
    а
    к
    о
    н
    а
    с
    о
    г
    л
    а
    с
    и
    я
    т
    р
    е
    т
    ь
    е
    г
    о
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    deal_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    с
    д
    е
    л
    к
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, deal_record=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 deal_record is None:
            self.deal_record = []
        else:
            self.deal_record = deal_record
        self.deal_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DealRecordsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DealRecordsType.subclass:
            return DealRecordsType.subclass(*args_, **kwargs_)
        else:
            return DealRecordsType(*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_deal_record(self):
        return self.deal_record
    def set_deal_record(self, deal_record):
        self.deal_record = deal_record
    def add_deal_record(self, value):
        self.deal_record.append(value)
    def insert_deal_record_at(self, index, value):
        self.deal_record.insert(index, value)
    def replace_deal_record_at(self, index, value):
        self.deal_record[index] = value
    def has__content(self):
        if (
            self.deal_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRecordsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DealRecordsType')
        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_ == 'DealRecordsType':
            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_='DealRecordsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DealRecordsType', 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_='DealRecordsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRecordsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for deal_record_ in self.deal_record:
            namespaceprefix_ = self.deal_record_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_record_nsprefix_) else ''
            deal_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deal_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'deal_record':
            obj_ = DealRecordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deal_record.append(obj_)
            obj_.original_tagname_ = 'deal_record'
# end class DealRecordsType


class DealRecordType(GeneratedsSuper):
    """DealRecordType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    с
    д
    е
    л
    к
    е
    ,
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    о
    й
    б
    е
    з
    н
    е
    о
    б
    х
    о
    д
    и
    м
    о
    г
    о
    в
    с
    и
    л
    у
    з
    а
    к
    о
    н
    а
    с
    о
    г
    л
    а
    с
    и
    я
    т
    р
    е
    т
    ь
    е
    г
    о
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    deal_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    с
    д
    е
    л
    к
    е
    (
    в
    и
    д
    с
    д
    е
    л
    к
    и
    )
    third_party_consents -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    е
    н
    и
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    с
    д
    е
    л
    к
    и
    ,
    п
    р
    а
    в
    а
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    ,
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    ы
    х
    б
    е
    з
    н
    е
    о
    б
    х
    о
    д
    и
    м
    о
    г
    о
    в
    с
    и
    л
    у
    з
    а
    к
    о
    н
    а
    с
    о
    г
    л
    а
    с
    и
    я
    т
    р
    е
    т
    ь
    е
    г
    о
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, deal_data=None, third_party_consents=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.deal_data = deal_data
        self.deal_data_nsprefix_ = None
        self.third_party_consents = third_party_consents
        self.third_party_consents_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DealRecordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DealRecordType.subclass:
            return DealRecordType.subclass(*args_, **kwargs_)
        else:
            return DealRecordType(*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_deal_data(self):
        return self.deal_data
    def set_deal_data(self, deal_data):
        self.deal_data = deal_data
    def get_third_party_consents(self):
        return self.third_party_consents
    def set_third_party_consents(self, third_party_consents):
        self.third_party_consents = third_party_consents
    def has__content(self):
        if (
            self.deal_data is not None or
            self.third_party_consents is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRecordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DealRecordType')
        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_ == 'DealRecordType':
            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_='DealRecordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DealRecordType', 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_='DealRecordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRecordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.deal_data is not None:
            namespaceprefix_ = self.deal_data_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_data_nsprefix_) else ''
            self.deal_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deal_data', pretty_print=pretty_print)
        if self.third_party_consents is not None:
            namespaceprefix_ = self.third_party_consents_nsprefix_ + ':' if (UseCapturedNS_ and self.third_party_consents_nsprefix_) else ''
            self.third_party_consents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='third_party_consents', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'deal_data':
            obj_ = DealDataType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deal_data = obj_
            obj_.original_tagname_ = 'deal_data'
        elif nodeName_ == 'third_party_consents':
            obj_ = ThirdPartyConsents.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.third_party_consents = obj_
            obj_.original_tagname_ = 'third_party_consents'
# end class DealRecordType


class DealDataType(GeneratedsSuper):
    """DealDataType -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    с
    д
    е
    л
    к
    е
    (
    в
    и
    д
    с
    д
    е
    л
    к
    и
    )
    deal_type -- В
    и
    д
    с
    д
    е
    л
    к
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, deal_type=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.deal_type = deal_type
        self.deal_type_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DealDataType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DealDataType.subclass:
            return DealDataType.subclass(*args_, **kwargs_)
        else:
            return DealDataType(*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_deal_type(self):
        return self.deal_type
    def set_deal_type(self, deal_type):
        self.deal_type = deal_type
    def has__content(self):
        if (
            self.deal_type is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealDataType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DealDataType')
        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_ == 'DealDataType':
            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_='DealDataType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DealDataType', 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_='DealDataType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealDataType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.deal_type is not None:
            namespaceprefix_ = self.deal_type_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_type_nsprefix_) else ''
            self.deal_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deal_type', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'deal_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deal_type = obj_
            obj_.original_tagname_ = 'deal_type'
# end class DealDataType


class FormLandWithdrawalAndNotDifferenntiated(GeneratedsSuper):
    """FormLandWithdrawalAndNotDifferenntiated -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    н
    а
    о
    с
    н
    о
    в
    а
    н
    и
    и
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    ,
    и
    л
    и
    и
    з
    з
    е
    м
    е
    л
    ь
    и
    л
    и
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ,
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    а
    я
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    ь
    н
    а
    к
    о
    т
    о
    р
    ы
    е
    н
    е
    р
    а
    з
    г
    р
    а
    н
    и
    ч
    е
    н
    а
    )
    form_land_state_not_differenntiated -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    и
    з
    з
    е
    м
    е
    л
    ь
    и
    л
    и
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ,
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    а
    я
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    ь
    н
    а
    к
    о
    т
    о
    р
    ы
    е
    н
    е
    р
    а
    з
    г
    р
    а
    н
    и
    ч
    е
    н
    а
    withdrawal_state_munic_needs -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    н
    а
    о
    с
    н
    о
    в
    а
    н
    и
    и
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    (
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    р
    е
    ш
    е
    н
    и
    я
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, form_land_state_not_differenntiated=None, withdrawal_state_munic_needs=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.form_land_state_not_differenntiated = form_land_state_not_differenntiated
        self.form_land_state_not_differenntiated_nsprefix_ = None
        self.withdrawal_state_munic_needs = withdrawal_state_munic_needs
        self.withdrawal_state_munic_needs_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, FormLandWithdrawalAndNotDifferenntiated)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if FormLandWithdrawalAndNotDifferenntiated.subclass:
            return FormLandWithdrawalAndNotDifferenntiated.subclass(*args_, **kwargs_)
        else:
            return FormLandWithdrawalAndNotDifferenntiated(*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_form_land_state_not_differenntiated(self):
        return self.form_land_state_not_differenntiated
    def set_form_land_state_not_differenntiated(self, form_land_state_not_differenntiated):
        self.form_land_state_not_differenntiated = form_land_state_not_differenntiated
    def get_withdrawal_state_munic_needs(self):
        return self.withdrawal_state_munic_needs
    def set_withdrawal_state_munic_needs(self, withdrawal_state_munic_needs):
        self.withdrawal_state_munic_needs = withdrawal_state_munic_needs
    def has__content(self):
        if (
            self.form_land_state_not_differenntiated is not None or
            self.withdrawal_state_munic_needs is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='FormLandWithdrawalAndNotDifferenntiated', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('FormLandWithdrawalAndNotDifferenntiated')
        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_ == 'FormLandWithdrawalAndNotDifferenntiated':
            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_='FormLandWithdrawalAndNotDifferenntiated')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='FormLandWithdrawalAndNotDifferenntiated', 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_='FormLandWithdrawalAndNotDifferenntiated'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='FormLandWithdrawalAndNotDifferenntiated', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.form_land_state_not_differenntiated is not None:
            namespaceprefix_ = self.form_land_state_not_differenntiated_nsprefix_ + ':' if (UseCapturedNS_ and self.form_land_state_not_differenntiated_nsprefix_) else ''
            self.form_land_state_not_differenntiated.export(outfile, level, namespaceprefix_, namespacedef_='', name_='form_land_state_not_differenntiated', pretty_print=pretty_print)
        if self.withdrawal_state_munic_needs is not None:
            namespaceprefix_ = self.withdrawal_state_munic_needs_nsprefix_ + ':' if (UseCapturedNS_ and self.withdrawal_state_munic_needs_nsprefix_) else ''
            self.withdrawal_state_munic_needs.export(outfile, level, namespaceprefix_, namespacedef_='', name_='withdrawal_state_munic_needs', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'form_land_state_not_differenntiated':
            obj_ = FormLandStateNotDifferenntiated.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.form_land_state_not_differenntiated = obj_
            obj_.original_tagname_ = 'form_land_state_not_differenntiated'
        elif nodeName_ == 'withdrawal_state_munic_needs':
            obj_ = WithdrawalStateMunicNeeds.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.withdrawal_state_munic_needs = obj_
            obj_.original_tagname_ = 'withdrawal_state_munic_needs'
# end class FormLandWithdrawalAndNotDifferenntiated


class FormLandStateNotDifferenntiated(GeneratedsSuper):
    """FormLandStateNotDifferenntiated -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    и
    з
    з
    е
    м
    е
    л
    ь
    и
    л
    и
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ,
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    а
    я
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    ь
    н
    а
    к
    о
    т
    о
    р
    ы
    е
    н
    е
    р
    а
    з
    г
    р
    а
    н
    и
    ч
    е
    н
    а
    name_authority -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    у
    п
    о
    л
    н
    о
    м
    о
    ч
    е
    н
    н
    о
    г
    о
    о
    р
    г
    а
    н
    а
    date_remove -- Д
    а
    т
    а
    с
    н
    я
    т
    и
    я
    с
    у
    ч
    е
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, name_authority=None, date_remove=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.name_authority = name_authority
        self.validate_MultiLiner(self.name_authority)
        self.name_authority_nsprefix_ = None
        if isinstance(date_remove, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_remove, '%Y-%m-%d').date()
        else:
            initvalue_ = date_remove
        self.date_remove = initvalue_
        self.date_remove_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, FormLandStateNotDifferenntiated)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if FormLandStateNotDifferenntiated.subclass:
            return FormLandStateNotDifferenntiated.subclass(*args_, **kwargs_)
        else:
            return FormLandStateNotDifferenntiated(*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_authority(self):
        return self.name_authority
    def set_name_authority(self, name_authority):
        self.name_authority = name_authority
    def get_date_remove(self):
        return self.date_remove
    def set_date_remove(self, date_remove):
        self.date_remove = date_remove
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.name_authority is not None or
            self.date_remove is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='FormLandStateNotDifferenntiated', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('FormLandStateNotDifferenntiated')
        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_ == 'FormLandStateNotDifferenntiated':
            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_='FormLandStateNotDifferenntiated')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='FormLandStateNotDifferenntiated', 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_='FormLandStateNotDifferenntiated'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='FormLandStateNotDifferenntiated', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.name_authority is not None:
            namespaceprefix_ = self.name_authority_nsprefix_ + ':' if (UseCapturedNS_ and self.name_authority_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_authority>%s</%sname_authority>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_authority), input_name='name_authority')), namespaceprefix_ , eol_))
        if self.date_remove is not None:
            namespaceprefix_ = self.date_remove_nsprefix_ + ':' if (UseCapturedNS_ and self.date_remove_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_remove>%s</%sdate_remove>%s' % (namespaceprefix_ , self.gds_format_date(self.date_remove, input_name='date_remove'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'name_authority':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_authority')
            value_ = self.gds_validate_string(value_, node, 'name_authority')
            self.name_authority = value_
            self.name_authority_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.name_authority)
        elif nodeName_ == 'date_remove':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_remove = dval_
            self.date_remove_nsprefix_ = child_.prefix
# end class FormLandStateNotDifferenntiated


class DateRemovedCadAccount(GeneratedsSuper):
    """DateRemovedCadAccount -- С
    в
    е
    д
    е
    н
    и
    я
    о
    н
    а
    л
    и
    ч
    и
    и
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    (c
    р
    о
    к
    с
    н
    я
    т
    и
    я
    с
    Г
    К
    У
    3
    г
    о
    д
    а
    )
    withdrawal_state_munic_needs -- С
    в
    е
    д
    е
    н
    и
    я
    о
    н
    а
    л
    и
    ч
    и
    и
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    (
    р
    е
    к
    в
    и
    з
    и
    т
    ы
    р
    е
    ш
    е
    н
    и
    я
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, withdrawal_state_munic_needs=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.withdrawal_state_munic_needs = withdrawal_state_munic_needs
        self.withdrawal_state_munic_needs_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DateRemovedCadAccount)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DateRemovedCadAccount.subclass:
            return DateRemovedCadAccount.subclass(*args_, **kwargs_)
        else:
            return DateRemovedCadAccount(*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_withdrawal_state_munic_needs(self):
        return self.withdrawal_state_munic_needs
    def set_withdrawal_state_munic_needs(self, withdrawal_state_munic_needs):
        self.withdrawal_state_munic_needs = withdrawal_state_munic_needs
    def has__content(self):
        if (
            self.withdrawal_state_munic_needs is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DateRemovedCadAccount', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DateRemovedCadAccount')
        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_ == 'DateRemovedCadAccount':
            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_='DateRemovedCadAccount')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DateRemovedCadAccount', 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_='DateRemovedCadAccount'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DateRemovedCadAccount', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.withdrawal_state_munic_needs is not None:
            namespaceprefix_ = self.withdrawal_state_munic_needs_nsprefix_ + ':' if (UseCapturedNS_ and self.withdrawal_state_munic_needs_nsprefix_) else ''
            self.withdrawal_state_munic_needs.export(outfile, level, namespaceprefix_, namespacedef_='', name_='withdrawal_state_munic_needs', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'withdrawal_state_munic_needs':
            obj_ = WithdrawalStateMunicNeeds.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.withdrawal_state_munic_needs = obj_
            obj_.original_tagname_ = 'withdrawal_state_munic_needs'
# end class DateRemovedCadAccount


class WithdrawalStateMunicNeeds(GeneratedsSuper):
    """WithdrawalStateMunicNeeds -- С
    в
    е
    д
    е
    н
    и
    я
    о
    н
    а
    л
    и
    ч
    и
    и
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    decision_attribute -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    р
    е
    ш
    е
    н
    и
    я
    о
    б
    и
    з
    ъ
    я
    т
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, decision_attribute=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.decision_attribute = decision_attribute
        self.decision_attribute_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, WithdrawalStateMunicNeeds)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if WithdrawalStateMunicNeeds.subclass:
            return WithdrawalStateMunicNeeds.subclass(*args_, **kwargs_)
        else:
            return WithdrawalStateMunicNeeds(*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_decision_attribute(self):
        return self.decision_attribute
    def set_decision_attribute(self, decision_attribute):
        self.decision_attribute = decision_attribute
    def has__content(self):
        if (
            self.decision_attribute is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='WithdrawalStateMunicNeeds', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('WithdrawalStateMunicNeeds')
        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_ == 'WithdrawalStateMunicNeeds':
            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_='WithdrawalStateMunicNeeds')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='WithdrawalStateMunicNeeds', 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_='WithdrawalStateMunicNeeds'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='WithdrawalStateMunicNeeds', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.decision_attribute is not None:
            namespaceprefix_ = self.decision_attribute_nsprefix_ + ':' if (UseCapturedNS_ and self.decision_attribute_nsprefix_) else ''
            self.decision_attribute.export(outfile, level, namespaceprefix_, namespacedef_='', name_='decision_attribute', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'decision_attribute':
            obj_ = DocRequisiteMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.decision_attribute = obj_
            obj_.original_tagname_ = 'decision_attribute'
# end class WithdrawalStateMunicNeeds


class SurveyBoundaries(GeneratedsSuper):
    """SurveyBoundaries -- У
    с
    л
    о
    в
    н
    ы
    й
    н
    о
    м
    е
    р
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    и
    с
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    ,
    в
    о
    т
    н
    о
    ш
    е
    н
    и
    и
    к
    о
    т
    о
    р
    о
    й
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    п
    р
    о
    е
    к
    т
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    registration_date -- Д
    а
    т
    а
    п
    р
    и
    с
    в
    о
    е
    н
    и
    я
    у
    ч
    е
    т
    н
    о
    г
    о
    н
    о
    м
    е
    р
    а
    п
    р
    о
    е
    к
    т
    у
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    survey_project_num -- У
    ч
    е
    т
    н
    ы
    й
    н
    о
    м
    е
    р
    п
    р
    о
    е
    к
    т
    а
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    nominal_number -- У
    с
    л
    о
    в
    н
    ы
    й
    н
    о
    м
    е
    р
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    decision_requisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    р
    е
    ш
    е
    н
    и
    я
    act_requisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    а
    к
    т
    а
    о
    б
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    и
    и
    п
    р
    о
    е
    к
    т
    а
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    approve_persons -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    е
    (
    л
    и
    ц
    а
    х
    ),
    у
    т
    в
    е
    р
    д
    и
    в
    ш
    и
    х
    п
    р
    о
    е
    к
    т
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    protocol_requisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    п
    р
    о
    т
    о
    к
    о
    л
    а
    ,
    п
    о
    д
    г
    о
    т
    о
    в
    л
    е
    н
    н
    о
    г
    о
    п
    о
    р
    е
    з
    у
    л
    ь
    т
    а
    т
    а
    м
    о
    б
    щ
    е
    г
    о
    с
    о
    б
    р
    а
    н
    и
    я
    у
    ч
    а
    с
    т
    н
    и
    к
    о
    в
    д
    о
    л
    е
    в
    о
    й
    с
    о
    б
    с
    т
    в
    е
    н
    н
    о
    с
    т
    и
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, registration_date=None, survey_project_num=None, nominal_number=None, decision_requisites=None, act_requisites=None, approve_persons=None, protocol_requisites=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(registration_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(registration_date, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = registration_date
        self.registration_date = initvalue_
        self.registration_date_nsprefix_ = None
        self.survey_project_num = survey_project_num
        self.survey_project_num_nsprefix_ = None
        self.nominal_number = nominal_number
        self.nominal_number_nsprefix_ = None
        self.decision_requisites = decision_requisites
        self.decision_requisites_nsprefix_ = None
        self.act_requisites = act_requisites
        self.act_requisites_nsprefix_ = None
        self.approve_persons = approve_persons
        self.approve_persons_nsprefix_ = None
        self.protocol_requisites = protocol_requisites
        self.protocol_requisites_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SurveyBoundaries)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SurveyBoundaries.subclass:
            return SurveyBoundaries.subclass(*args_, **kwargs_)
        else:
            return SurveyBoundaries(*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_registration_date(self):
        return self.registration_date
    def set_registration_date(self, registration_date):
        self.registration_date = registration_date
    def get_survey_project_num(self):
        return self.survey_project_num
    def set_survey_project_num(self, survey_project_num):
        self.survey_project_num = survey_project_num
    def get_nominal_number(self):
        return self.nominal_number
    def set_nominal_number(self, nominal_number):
        self.nominal_number = nominal_number
    def get_decision_requisites(self):
        return self.decision_requisites
    def set_decision_requisites(self, decision_requisites):
        self.decision_requisites = decision_requisites
    def get_act_requisites(self):
        return self.act_requisites
    def set_act_requisites(self, act_requisites):
        self.act_requisites = act_requisites
    def get_approve_persons(self):
        return self.approve_persons
    def set_approve_persons(self, approve_persons):
        self.approve_persons = approve_persons
    def get_protocol_requisites(self):
        return self.protocol_requisites
    def set_protocol_requisites(self, protocol_requisites):
        self.protocol_requisites = protocol_requisites
    def has__content(self):
        if (
            self.registration_date is not None or
            self.survey_project_num is not None or
            self.nominal_number is not None or
            self.decision_requisites is not None or
            self.act_requisites is not None or
            self.approve_persons is not None or
            self.protocol_requisites is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SurveyBoundaries', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SurveyBoundaries')
        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_ == 'SurveyBoundaries':
            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_='SurveyBoundaries')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SurveyBoundaries', 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_='SurveyBoundaries'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SurveyBoundaries', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.registration_date is not None:
            namespaceprefix_ = self.registration_date_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_date>%s</%sregistration_date>%s' % (namespaceprefix_ , self.gds_format_datetime(self.registration_date, input_name='registration_date'), namespaceprefix_ , eol_))
        if self.survey_project_num is not None:
            namespaceprefix_ = self.survey_project_num_nsprefix_ + ':' if (UseCapturedNS_ and self.survey_project_num_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssurvey_project_num>%s</%ssurvey_project_num>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.survey_project_num), input_name='survey_project_num')), namespaceprefix_ , eol_))
        if self.nominal_number is not None:
            namespaceprefix_ = self.nominal_number_nsprefix_ + ':' if (UseCapturedNS_ and self.nominal_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snominal_number>%s</%snominal_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.nominal_number), input_name='nominal_number')), namespaceprefix_ , eol_))
        if self.decision_requisites is not None:
            namespaceprefix_ = self.decision_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.decision_requisites_nsprefix_) else ''
            self.decision_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='decision_requisites', pretty_print=pretty_print)
        if self.act_requisites is not None:
            namespaceprefix_ = self.act_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.act_requisites_nsprefix_) else ''
            self.act_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='act_requisites', pretty_print=pretty_print)
        if self.approve_persons is not None:
            namespaceprefix_ = self.approve_persons_nsprefix_ + ':' if (UseCapturedNS_ and self.approve_persons_nsprefix_) else ''
            self.approve_persons.export(outfile, level, namespaceprefix_, namespacedef_='', name_='approve_persons', pretty_print=pretty_print)
        if self.protocol_requisites is not None:
            namespaceprefix_ = self.protocol_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.protocol_requisites_nsprefix_) else ''
            self.protocol_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='protocol_requisites', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'registration_date':
            sval_ = child_.text
            dval_ = self.gds_parse_datetime(sval_)
            self.registration_date = dval_
            self.registration_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'survey_project_num':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'survey_project_num')
            value_ = self.gds_validate_string(value_, node, 'survey_project_num')
            self.survey_project_num = value_
            self.survey_project_num_nsprefix_ = child_.prefix
        elif nodeName_ == 'nominal_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'nominal_number')
            value_ = self.gds_validate_string(value_, node, 'nominal_number')
            self.nominal_number = value_
            self.nominal_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'decision_requisites':
            obj_ = DocRequisiteMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.decision_requisites = obj_
            obj_.original_tagname_ = 'decision_requisites'
        elif nodeName_ == 'act_requisites':
            obj_ = DocRequisiteMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.act_requisites = obj_
            obj_.original_tagname_ = 'act_requisites'
        elif nodeName_ == 'approve_persons':
            obj_ = ApprovePersons.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.approve_persons = obj_
            obj_.original_tagname_ = 'approve_persons'
        elif nodeName_ == 'protocol_requisites':
            obj_ = DocRequisiteMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.protocol_requisites = obj_
            obj_.original_tagname_ = 'protocol_requisites'
# end class SurveyBoundaries


class ApprovePersons(GeneratedsSuper):
    """ApprovePersons -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    е
    (
    л
    и
    ц
    а
    х
    ),
    у
    т
    в
    е
    р
    д
    и
    в
    ш
    и
    х
    п
    р
    о
    е
    к
    т
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    approve_person -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    е
    ,
    у
    т
    в
    е
    р
    д
    и
    в
    ш
    е
    м
    п
    р
    о
    е
    к
    т
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, approve_person=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 approve_person is None:
            self.approve_person = []
        else:
            self.approve_person = approve_person
        self.approve_person_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ApprovePersons)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ApprovePersons.subclass:
            return ApprovePersons.subclass(*args_, **kwargs_)
        else:
            return ApprovePersons(*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_approve_person(self):
        return self.approve_person
    def set_approve_person(self, approve_person):
        self.approve_person = approve_person
    def add_approve_person(self, value):
        self.approve_person.append(value)
    def insert_approve_person_at(self, index, value):
        self.approve_person.insert(index, value)
    def replace_approve_person_at(self, index, value):
        self.approve_person[index] = value
    def has__content(self):
        if (
            self.approve_person
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ApprovePersons', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ApprovePersons')
        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_ == 'ApprovePersons':
            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_='ApprovePersons')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ApprovePersons', 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_='ApprovePersons'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ApprovePersons', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for approve_person_ in self.approve_person:
            namespaceprefix_ = self.approve_person_nsprefix_ + ':' if (UseCapturedNS_ and self.approve_person_nsprefix_) else ''
            approve_person_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='approve_person', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'approve_person':
            obj_ = approve_personType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.approve_person.append(obj_)
            obj_.original_tagname_ = 'approve_person'
# end class ApprovePersons


class ThirdPartyConsents(GeneratedsSuper):
    """ThirdPartyConsents -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    е
    н
    и
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    с
    д
    е
    л
    к
    и
    ,
    п
    р
    а
    в
    а
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    ,
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    ы
    х
    б
    е
    з
    н
    е
    о
    б
    х
    о
    д
    и
    м
    о
    г
    о
    в
    с
    и
    л
    у
    з
    а
    к
    о
    н
    а
    с
    о
    г
    л
    а
    с
    и
    я
    т
    р
    е
    т
    ь
    е
    г
    о
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    third_party_consent -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    е
    н
    и
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    с
    д
    е
    л
    к
    и
    ,
    п
    р
    а
    в
    а
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    б
    е
    з
    н
    е
    о
    б
    х
    о
    д
    и
    м
    о
    г
    о
    в
    с
    и
    л
    у
    з
    а
    к
    о
    н
    а
    с
    о
    г
    л
    а
    с
    и
    я
    т
    р
    е
    т
    ь
    е
    г
    о
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, third_party_consent=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 third_party_consent is None:
            self.third_party_consent = []
        else:
            self.third_party_consent = third_party_consent
        self.third_party_consent_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ThirdPartyConsents)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ThirdPartyConsents.subclass:
            return ThirdPartyConsents.subclass(*args_, **kwargs_)
        else:
            return ThirdPartyConsents(*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_third_party_consent(self):
        return self.third_party_consent
    def set_third_party_consent(self, third_party_consent):
        self.third_party_consent = third_party_consent
    def add_third_party_consent(self, value):
        self.third_party_consent.append(value)
    def insert_third_party_consent_at(self, index, value):
        self.third_party_consent.insert(index, value)
    def replace_third_party_consent_at(self, index, value):
        self.third_party_consent[index] = value
    def has__content(self):
        if (
            self.third_party_consent
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ThirdPartyConsents', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ThirdPartyConsents')
        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_ == 'ThirdPartyConsents':
            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_='ThirdPartyConsents')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ThirdPartyConsents', 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_='ThirdPartyConsents'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ThirdPartyConsents', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for third_party_consent_ in self.third_party_consent:
            namespaceprefix_ = self.third_party_consent_nsprefix_ + ':' if (UseCapturedNS_ and self.third_party_consent_nsprefix_) else ''
            third_party_consent_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='third_party_consent', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'third_party_consent':
            obj_ = ThirdPartyConsent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.third_party_consent.append(obj_)
            obj_.original_tagname_ = 'third_party_consent'
# end class ThirdPartyConsents


class ThirdPartyConsent(GeneratedsSuper):
    """ThirdPartyConsent -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    е
    н
    и
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    с
    д
    е
    л
    к
    и
    ,
    п
    р
    а
    в
    а
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    ,
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    ы
    х
    б
    е
    з
    н
    е
    о
    б
    х
    о
    д
    и
    м
    о
    г
    о
    в
    с
    и
    л
    у
    з
    а
    к
    о
    н
    а
    с
    о
    г
    л
    а
    с
    и
    я
    т
    р
    е
    т
    ь
    е
    г
    о
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    law -- Ф
    е
    д
    е
    р
    а
    л
    ь
    н
    ы
    й
    з
    а
    к
    о
    н
    ,
    к
    о
    т
    о
    р
    ы
    м
    п
    р
    е
    д
    у
    с
    м
    о
    т
    р
    е
    н
    о
    п
    о
    л
    у
    ч
    е
    н
    и
    е
    с
    о
    г
    л
    а
    с
    и
    я
    н
    а
    с
    о
    в
    е
    р
    ш
    е
    н
    и
    е
    с
    д
    е
    л
    к
    и
    dissenting_entities -- Н
    е
    п
    р
    е
    д
    с
    т
    а
    в
    л
    е
    н
    о
    с
    о
    г
    л
    а
    с
    и
    е
    н
    а
    с
    о
    в
    е
    р
    ш
    е
    н
    и
    е
    с
    д
    е
    л
    к
    и
    mark_content -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    т
    м
    е
    т
    к
    и
    п
    р
    и
    в
    о
    з
    н
    и
    к
    н
    о
    в
    е
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, law=None, dissenting_entities=None, mark_content=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.law = law
        self.law_nsprefix_ = None
        self.dissenting_entities = dissenting_entities
        self.dissenting_entities_nsprefix_ = None
        self.mark_content = mark_content
        self.mark_content_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ThirdPartyConsent)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ThirdPartyConsent.subclass:
            return ThirdPartyConsent.subclass(*args_, **kwargs_)
        else:
            return ThirdPartyConsent(*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_law(self):
        return self.law
    def set_law(self, law):
        self.law = law
    def get_dissenting_entities(self):
        return self.dissenting_entities
    def set_dissenting_entities(self, dissenting_entities):
        self.dissenting_entities = dissenting_entities
    def get_mark_content(self):
        return self.mark_content
    def set_mark_content(self, mark_content):
        self.mark_content = mark_content
    def has__content(self):
        if (
            self.law is not None or
            self.dissenting_entities is not None or
            self.mark_content is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ThirdPartyConsent', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ThirdPartyConsent')
        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_ == 'ThirdPartyConsent':
            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_='ThirdPartyConsent')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ThirdPartyConsent', 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_='ThirdPartyConsent'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ThirdPartyConsent', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.law is not None:
            namespaceprefix_ = self.law_nsprefix_ + ':' if (UseCapturedNS_ and self.law_nsprefix_) else ''
            self.law.export(outfile, level, namespaceprefix_, namespacedef_='', name_='law', pretty_print=pretty_print)
        if self.dissenting_entities is not None:
            namespaceprefix_ = self.dissenting_entities_nsprefix_ + ':' if (UseCapturedNS_ and self.dissenting_entities_nsprefix_) else ''
            self.dissenting_entities.export(outfile, level, namespaceprefix_, namespacedef_='', name_='dissenting_entities', pretty_print=pretty_print)
        if self.mark_content is not None:
            namespaceprefix_ = self.mark_content_nsprefix_ + ':' if (UseCapturedNS_ and self.mark_content_nsprefix_) else ''
            self.mark_content.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mark_content', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'law':
            obj_ = Law.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.law = obj_
            obj_.original_tagname_ = 'law'
        elif nodeName_ == 'dissenting_entities':
            obj_ = DissentingEntities.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.dissenting_entities = obj_
            obj_.original_tagname_ = 'dissenting_entities'
        elif nodeName_ == 'mark_content':
            obj_ = MarkContent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.mark_content = obj_
            obj_.original_tagname_ = 'mark_content'
# end class ThirdPartyConsent


class DissentingEntities(GeneratedsSuper):
    """DissentingEntities -- Н
    е
    п
    р
    е
    д
    с
    т
    а
    в
    л
    е
    н
    о
    с
    о
    г
    л
    а
    с
    и
    е
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    dissenting_entity -- Н
    е
    п
    р
    е
    д
    с
    т
    а
    в
    л
    е
    н
    о
    с
    о
    г
    л
    а
    с
    и
    е
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, dissenting_entity=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 dissenting_entity is None:
            self.dissenting_entity = []
        else:
            self.dissenting_entity = dissenting_entity
        self.dissenting_entity_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DissentingEntities)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DissentingEntities.subclass:
            return DissentingEntities.subclass(*args_, **kwargs_)
        else:
            return DissentingEntities(*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_dissenting_entity(self):
        return self.dissenting_entity
    def set_dissenting_entity(self, dissenting_entity):
        self.dissenting_entity = dissenting_entity
    def add_dissenting_entity(self, value):
        self.dissenting_entity.append(value)
    def insert_dissenting_entity_at(self, index, value):
        self.dissenting_entity.insert(index, value)
    def replace_dissenting_entity_at(self, index, value):
        self.dissenting_entity[index] = value
    def has__content(self):
        if (
            self.dissenting_entity
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DissentingEntities', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DissentingEntities')
        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_ == 'DissentingEntities':
            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_='DissentingEntities')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DissentingEntities', 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_='DissentingEntities'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DissentingEntities', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for dissenting_entity_ in self.dissenting_entity:
            namespaceprefix_ = self.dissenting_entity_nsprefix_ + ':' if (UseCapturedNS_ and self.dissenting_entity_nsprefix_) else ''
            dissenting_entity_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='dissenting_entity', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'dissenting_entity':
            obj_ = dissenting_entityType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.dissenting_entity.append(obj_)
            obj_.original_tagname_ = 'dissenting_entity'
# end class DissentingEntities


class NonRegistrabilitys(GeneratedsSuper):
    """NonRegistrabilitys -- С
    в
    е
    д
    е
    н
    и
    я
    о
    н
    е
    в
    о
    з
    м
    о
    ж
    н
    о
    с
    т
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    е
    р
    е
    х
    о
    д
    а
    ,
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    я
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    и
    з
    з
    е
    м
    е
    л
    ь
    с
    е
    л
    ь
    с
    к
    о
    х
    о
    з
    я
    й
    с
    т
    в
    е
    н
    н
    о
    г
    о
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    я
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    т
    а
    к
    о
    г
    о
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    д
    о
    з
    а
    в
    е
    р
    ш
    е
    н
    и
    я
    р
    а
    с
    с
    м
    о
    т
    р
    е
    н
    и
    я
    с
    у
    д
    о
    м
    д
    е
    л
    а
    о
    е
    г
    о
    и
    з
    ъ
    я
    т
    и
    и
    в
    с
    в
    я
    з
    и
    с
    н
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    м
    п
    о
    ц
    е
    л
    е
    в
    о
    м
    у
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    ю
    и
    л
    и
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    м
    с
    н
    а
    р
    у
    ш
    е
    н
    и
    е
    м
    з
    а
    к
    о
    н
    о
    д
    а
    т
    е
    л
    ь
    с
    т
    в
    а
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    non_registrability -- С
    в
    е
    д
    е
    н
    и
    я
    о
    н
    е
    в
    о
    з
    м
    о
    ж
    н
    о
    с
    т
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    е
    р
    е
    х
    о
    д
    а
    ,
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    я
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    и
    з
    з
    е
    м
    е
    л
    ь
    с
    е
    л
    ь
    с
    к
    о
    х
    о
    з
    я
    й
    с
    т
    в
    е
    н
    н
    о
    г
    о
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    я
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    т
    а
    к
    о
    г
    о
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    д
    о
    з
    а
    в
    е
    р
    ш
    е
    н
    и
    я
    р
    а
    с
    с
    м
    о
    т
    р
    е
    н
    и
    я
    с
    у
    д
    о
    м
    д
    е
    л
    а
    о
    е
    г
    о
    и
    з
    ъ
    я
    т
    и
    и
    в
    с
    в
    я
    з
    и
    с
    н
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    м
    п
    о
    ц
    е
    л
    е
    в
    о
    м
    у
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    ю
    и
    л
    и
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    м
    с
    н
    а
    р
    у
    ш
    е
    н
    и
    е
    м
    з
    а
    к
    о
    н
    о
    д
    а
    т
    е
    л
    ь
    с
    т
    в
    а
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, non_registrability=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 non_registrability is None:
            self.non_registrability = []
        else:
            self.non_registrability = non_registrability
        self.non_registrability_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, NonRegistrabilitys)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if NonRegistrabilitys.subclass:
            return NonRegistrabilitys.subclass(*args_, **kwargs_)
        else:
            return NonRegistrabilitys(*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_non_registrability(self):
        return self.non_registrability
    def set_non_registrability(self, non_registrability):
        self.non_registrability = non_registrability
    def add_non_registrability(self, value):
        self.non_registrability.append(value)
    def insert_non_registrability_at(self, index, value):
        self.non_registrability.insert(index, value)
    def replace_non_registrability_at(self, index, value):
        self.non_registrability[index] = value
    def has__content(self):
        if (
            self.non_registrability
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NonRegistrabilitys', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('NonRegistrabilitys')
        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_ == 'NonRegistrabilitys':
            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_='NonRegistrabilitys')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NonRegistrabilitys', 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_='NonRegistrabilitys'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NonRegistrabilitys', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for non_registrability_ in self.non_registrability:
            namespaceprefix_ = self.non_registrability_nsprefix_ + ':' if (UseCapturedNS_ and self.non_registrability_nsprefix_) else ''
            non_registrability_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='non_registrability', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'non_registrability':
            obj_ = NonRegistrability.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.non_registrability.append(obj_)
            obj_.original_tagname_ = 'non_registrability'
# end class NonRegistrabilitys


class NonRegistrability(GeneratedsSuper):
    """NonRegistrability -- С
    в
    е
    д
    е
    н
    и
    я
    о
    н
    е
    в
    о
    з
    м
    о
    ж
    н
    о
    с
    т
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    е
    р
    е
    х
    о
    д
    а
    ,
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    я
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    и
    з
    з
    е
    м
    е
    л
    ь
    с
    е
    л
    ь
    с
    к
    о
    х
    о
    з
    я
    й
    с
    т
    в
    е
    н
    н
    о
    г
    о
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    я
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    т
    а
    к
    о
    г
    о
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    д
    о
    з
    а
    в
    е
    р
    ш
    е
    н
    и
    я
    р
    а
    с
    с
    м
    о
    т
    р
    е
    н
    и
    я
    с
    у
    д
    о
    м
    д
    е
    л
    а
    о
    е
    г
    о
    и
    з
    ъ
    я
    т
    и
    и
    в
    с
    в
    я
    з
    и
    с
    н
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    м
    п
    о
    ц
    е
    л
    е
    в
    о
    м
    у
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    ю
    и
    л
    и
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    м
    с
    н
    а
    р
    у
    ш
    е
    н
    и
    е
    м
    з
    а
    к
    о
    н
    о
    д
    а
    т
    е
    л
    ь
    с
    т
    в
    а
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    non_registrability_info -- П
    р
    и
    н
    я
    т
    о
    з
    а
    я
    в
    л
    е
    н
    и
    е
    о
    н
    е
    в
    о
    з
    м
    о
    ж
    н
    о
    с
    т
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    е
    р
    е
    х
    о
    д
    а
    ,
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    я
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    и
    з
    з
    е
    м
    е
    л
    ь
    с
    е
    л
    ь
    с
    к
    о
    х
    о
    з
    я
    й
    с
    т
    в
    е
    н
    н
    о
    г
    о
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    я
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    т
    а
    к
    о
    г
    о
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, non_registrability_info=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.non_registrability_info = non_registrability_info
        self.non_registrability_info_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, NonRegistrability)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if NonRegistrability.subclass:
            return NonRegistrability.subclass(*args_, **kwargs_)
        else:
            return NonRegistrability(*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_non_registrability_info(self):
        return self.non_registrability_info
    def set_non_registrability_info(self, non_registrability_info):
        self.non_registrability_info = non_registrability_info
    def has__content(self):
        if (
            self.non_registrability_info is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NonRegistrability', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('NonRegistrability')
        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_ == 'NonRegistrability':
            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_='NonRegistrability')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NonRegistrability', 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_='NonRegistrability'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NonRegistrability', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.non_registrability_info is not None:
            namespaceprefix_ = self.non_registrability_info_nsprefix_ + ':' if (UseCapturedNS_ and self.non_registrability_info_nsprefix_) else ''
            self.non_registrability_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='non_registrability_info', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'non_registrability_info':
            obj_ = OriginContent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.non_registrability_info = obj_
            obj_.original_tagname_ = 'non_registrability_info'
# end class NonRegistrability


class Law(GeneratedsSuper):
    """Law -- Ф
    е
    д
    е
    р
    а
    л
    ь
    н
    ы
    й
    з
    а
    к
    о
    н
    ,
    к
    о
    т
    о
    р
    ы
    м
    п
    р
    е
    д
    у
    с
    м
    о
    т
    р
    е
    н
    о
    п
    о
    л
    у
    ч
    е
    н
    и
    е
    с
    о
    г
    л
    а
    с
    и
    я
    н
    а
    с
    о
    в
    е
    р
    ш
    е
    н
    и
    е
    с
    д
    е
    л
    к
    и
    section -- Ч
    а
    с
    т
    ь
    paragraph -- П
    у
    н
    к
    т
    article -- С
    т
    а
    т
    ь
    я
    law_date -- Д
    а
    т
    а
    number -- Н
    о
    м
    е
    р
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, section=None, paragraph=None, article=None, law_date=None, number=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.section = section
        self.section_nsprefix_ = None
        self.paragraph = paragraph
        self.paragraph_nsprefix_ = None
        self.article = article
        self.article_nsprefix_ = None
        self.law_date = law_date
        self.law_date_nsprefix_ = None
        self.number = number
        self.number_nsprefix_ = None
        self.name = name
        self.validate_MultiLiner(self.name)
        self.name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Law)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Law.subclass:
            return Law.subclass(*args_, **kwargs_)
        else:
            return Law(*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_section(self):
        return self.section
    def set_section(self, section):
        self.section = section
    def get_paragraph(self):
        return self.paragraph
    def set_paragraph(self, paragraph):
        self.paragraph = paragraph
    def get_article(self):
        return self.article
    def set_article(self, article):
        self.article = article
    def get_law_date(self):
        return self.law_date
    def set_law_date(self, law_date):
        self.law_date = law_date
    def get_number(self):
        return self.number
    def set_number(self, number):
        self.number = number
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.section is not None or
            self.paragraph is not None or
            self.article is not None or
            self.law_date is not None or
            self.number is not None or
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Law', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Law')
        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_ == 'Law':
            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_='Law')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Law', 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_='Law'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Law', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.section is not None:
            namespaceprefix_ = self.section_nsprefix_ + ':' if (UseCapturedNS_ and self.section_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssection>%s</%ssection>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.section), input_name='section')), namespaceprefix_ , eol_))
        if self.paragraph is not None:
            namespaceprefix_ = self.paragraph_nsprefix_ + ':' if (UseCapturedNS_ and self.paragraph_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sparagraph>%s</%sparagraph>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.paragraph), input_name='paragraph')), namespaceprefix_ , eol_))
        if self.article is not None:
            namespaceprefix_ = self.article_nsprefix_ + ':' if (UseCapturedNS_ and self.article_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarticle>%s</%sarticle>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.article), input_name='article')), namespaceprefix_ , eol_))
        if self.law_date is not None:
            namespaceprefix_ = self.law_date_nsprefix_ + ':' if (UseCapturedNS_ and self.law_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%slaw_date>%s</%slaw_date>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.law_date), input_name='law_date')), namespaceprefix_ , 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.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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'section':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'section')
            value_ = self.gds_validate_string(value_, node, 'section')
            self.section = value_
            self.section_nsprefix_ = child_.prefix
        elif nodeName_ == 'paragraph':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'paragraph')
            value_ = self.gds_validate_string(value_, node, 'paragraph')
            self.paragraph = value_
            self.paragraph_nsprefix_ = child_.prefix
        elif nodeName_ == 'article':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'article')
            value_ = self.gds_validate_string(value_, node, 'article')
            self.article = value_
            self.article_nsprefix_ = child_.prefix
        elif nodeName_ == 'law_date':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'law_date')
            value_ = self.gds_validate_string(value_, node, 'law_date')
            self.law_date = value_
            self.law_date_nsprefix_ = child_.prefix
        elif 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_ == '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
            # validate type MultiLiner
            self.validate_MultiLiner(self.name)
# end class Law


class MarkContent(GeneratedsSuper):
    """MarkContent -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    т
    м
    е
    т
    к
    и
    origin_mark -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    т
    м
    е
    т
    к
    и
    п
    р
    и
    в
    о
    з
    н
    и
    к
    н
    о
    в
    е
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, origin_mark=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.origin_mark = origin_mark
        self.origin_mark_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, MarkContent)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if MarkContent.subclass:
            return MarkContent.subclass(*args_, **kwargs_)
        else:
            return MarkContent(*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_origin_mark(self):
        return self.origin_mark
    def set_origin_mark(self, origin_mark):
        self.origin_mark = origin_mark
    def has__content(self):
        if (
            self.origin_mark is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MarkContent', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('MarkContent')
        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_ == 'MarkContent':
            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_='MarkContent')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MarkContent', 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_='MarkContent'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MarkContent', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.origin_mark is not None:
            namespaceprefix_ = self.origin_mark_nsprefix_ + ':' if (UseCapturedNS_ and self.origin_mark_nsprefix_) else ''
            self.origin_mark.export(outfile, level, namespaceprefix_, namespacedef_='', name_='origin_mark', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'origin_mark':
            obj_ = OriginContent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.origin_mark = obj_
            obj_.original_tagname_ = 'origin_mark'
# end class MarkContent


class OriginContent(GeneratedsSuper):
    """OriginContent -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    origin_content -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, origin_content=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.origin_content = origin_content
        self.validate_MultiLiner(self.origin_content)
        self.origin_content_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OriginContent)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OriginContent.subclass:
            return OriginContent.subclass(*args_, **kwargs_)
        else:
            return OriginContent(*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_origin_content(self):
        return self.origin_content
    def set_origin_content(self, origin_content):
        self.origin_content = origin_content
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.origin_content is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OriginContent', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OriginContent')
        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_ == 'OriginContent':
            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_='OriginContent')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OriginContent', 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_='OriginContent'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OriginContent', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.origin_content is not None:
            namespaceprefix_ = self.origin_content_nsprefix_ + ':' if (UseCapturedNS_ and self.origin_content_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sorigin_content>%s</%sorigin_content>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.origin_content), input_name='origin_content')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'origin_content':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'origin_content')
            value_ = self.gds_validate_string(value_, node, 'origin_content')
            self.origin_content = value_
            self.origin_content_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.origin_content)
# end class OriginContent


class IncapacityIndividual(GeneratedsSuper):
    """IncapacityIndividual -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    и
    з
    н
    а
    н
    и
    и
    г
    р
    а
    ж
    д
    а
    н
    и
    н
    а
    (
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    )
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    н
    ы
    м
    в
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    о
    с
    т
    и
    и
    л
    и
    н
    е
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    individual -- Ф
    и
    з
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    incapacity_info -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    и
    з
    н
    а
    н
    и
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    н
    е
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    н
    о
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, individual=None, incapacity_info=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.individual = individual
        self.individual_nsprefix_ = None
        self.incapacity_info = incapacity_info
        self.incapacity_info_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IncapacityIndividual)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IncapacityIndividual.subclass:
            return IncapacityIndividual.subclass(*args_, **kwargs_)
        else:
            return IncapacityIndividual(*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_individual(self):
        return self.individual
    def set_individual(self, individual):
        self.individual = individual
    def get_incapacity_info(self):
        return self.incapacity_info
    def set_incapacity_info(self, incapacity_info):
        self.incapacity_info = incapacity_info
    def has__content(self):
        if (
            self.individual is not None or
            self.incapacity_info is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncapacityIndividual', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IncapacityIndividual')
        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_ == 'IncapacityIndividual':
            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_='IncapacityIndividual')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IncapacityIndividual', 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_='IncapacityIndividual'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncapacityIndividual', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.individual is not None:
            namespaceprefix_ = self.individual_nsprefix_ + ':' if (UseCapturedNS_ and self.individual_nsprefix_) else ''
            self.individual.export(outfile, level, namespaceprefix_, namespacedef_='', name_='individual', pretty_print=pretty_print)
        if self.incapacity_info is not None:
            namespaceprefix_ = self.incapacity_info_nsprefix_ + ':' if (UseCapturedNS_ and self.incapacity_info_nsprefix_) else ''
            self.incapacity_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='incapacity_info', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'individual':
            obj_ = IndividualFull.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.individual = obj_
            obj_.original_tagname_ = 'individual'
        elif nodeName_ == 'incapacity_info':
            obj_ = IncapacityInfo.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.incapacity_info = obj_
            obj_.original_tagname_ = 'incapacity_info'
# end class IncapacityIndividual


class IncapacityInfo(GeneratedsSuper):
    """IncapacityInfo -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    и
    з
    н
    а
    н
    и
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    н
    е
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    н
    о
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    incapacity_info_type -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    и
    з
    н
    а
    н
    и
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    н
    е
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    н
    о
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, incapacity_info_type=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.incapacity_info_type = incapacity_info_type
        self.incapacity_info_type_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IncapacityInfo)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IncapacityInfo.subclass:
            return IncapacityInfo.subclass(*args_, **kwargs_)
        else:
            return IncapacityInfo(*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_incapacity_info_type(self):
        return self.incapacity_info_type
    def set_incapacity_info_type(self, incapacity_info_type):
        self.incapacity_info_type = incapacity_info_type
    def has__content(self):
        if (
            self.incapacity_info_type is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncapacityInfo', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IncapacityInfo')
        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_ == 'IncapacityInfo':
            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_='IncapacityInfo')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IncapacityInfo', 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_='IncapacityInfo'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncapacityInfo', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.incapacity_info_type is not None:
            namespaceprefix_ = self.incapacity_info_type_nsprefix_ + ':' if (UseCapturedNS_ and self.incapacity_info_type_nsprefix_) else ''
            self.incapacity_info_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='incapacity_info_type', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'incapacity_info_type':
            obj_ = IncapacityInfoType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.incapacity_info_type = obj_
            obj_.original_tagname_ = 'incapacity_info_type'
# end class IncapacityInfo


class IncapacityInfoType(GeneratedsSuper):
    """IncapacityInfoType -- П
    р
    и
    з
    н
    а
    н
    и
    е
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    н
    е
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    н
    о
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    limited_capacity -- П
    р
    и
    з
    н
    а
    н
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    н
    о
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    declared_incapable -- П
    р
    и
    з
    н
    а
    н
    н
    е
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, limited_capacity=None, declared_incapable=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.limited_capacity = limited_capacity
        self.limited_capacity_nsprefix_ = None
        self.declared_incapable = declared_incapable
        self.declared_incapable_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IncapacityInfoType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IncapacityInfoType.subclass:
            return IncapacityInfoType.subclass(*args_, **kwargs_)
        else:
            return IncapacityInfoType(*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_limited_capacity(self):
        return self.limited_capacity
    def set_limited_capacity(self, limited_capacity):
        self.limited_capacity = limited_capacity
    def get_declared_incapable(self):
        return self.declared_incapable
    def set_declared_incapable(self, declared_incapable):
        self.declared_incapable = declared_incapable
    def has__content(self):
        if (
            self.limited_capacity is not None or
            self.declared_incapable is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncapacityInfoType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IncapacityInfoType')
        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_ == 'IncapacityInfoType':
            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_='IncapacityInfoType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IncapacityInfoType', 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_='IncapacityInfoType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncapacityInfoType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.limited_capacity is not None:
            namespaceprefix_ = self.limited_capacity_nsprefix_ + ':' if (UseCapturedNS_ and self.limited_capacity_nsprefix_) else ''
            self.limited_capacity.export(outfile, level, namespaceprefix_, namespacedef_='', name_='limited_capacity', pretty_print=pretty_print)
        if self.declared_incapable is not None:
            namespaceprefix_ = self.declared_incapable_nsprefix_ + ':' if (UseCapturedNS_ and self.declared_incapable_nsprefix_) else ''
            self.declared_incapable.export(outfile, level, namespaceprefix_, namespacedef_='', name_='declared_incapable', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'limited_capacity':
            obj_ = CourtDecisionOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.limited_capacity = obj_
            obj_.original_tagname_ = 'limited_capacity'
        elif nodeName_ == 'declared_incapable':
            obj_ = CourtDecisionOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.declared_incapable = obj_
            obj_.original_tagname_ = 'declared_incapable'
# end class IncapacityInfoType


class RestrictRecordsBaseParams(GeneratedsSuper):
    """RestrictRecordsBaseParams -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restrict_record -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restrict_record=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 restrict_record is None:
            self.restrict_record = []
        else:
            self.restrict_record = restrict_record
        self.restrict_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictRecordsBaseParams)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictRecordsBaseParams.subclass:
            return RestrictRecordsBaseParams.subclass(*args_, **kwargs_)
        else:
            return RestrictRecordsBaseParams(*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_restrict_record(self):
        return self.restrict_record
    def set_restrict_record(self, restrict_record):
        self.restrict_record = restrict_record
    def add_restrict_record(self, value):
        self.restrict_record.append(value)
    def insert_restrict_record_at(self, index, value):
        self.restrict_record.insert(index, value)
    def replace_restrict_record_at(self, index, value):
        self.restrict_record[index] = value
    def has__content(self):
        if (
            self.restrict_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordsBaseParams', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictRecordsBaseParams')
        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_ == 'RestrictRecordsBaseParams':
            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_='RestrictRecordsBaseParams')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictRecordsBaseParams', 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_='RestrictRecordsBaseParams'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordsBaseParams', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restrict_record_ in self.restrict_record:
            namespaceprefix_ = self.restrict_record_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_record_nsprefix_) else ''
            restrict_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restrict_record':
            obj_ = RestrictRecordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_record.append(obj_)
            obj_.original_tagname_ = 'restrict_record'
# end class RestrictRecordsBaseParams


class RestrictRecordType(GeneratedsSuper):
    """RestrictRecordType -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    record_info -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    restrictions_encumbrances_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    restrict_parties -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    а
    х
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    ,
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    underlying_documents -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    third_party_consents -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    е
    н
    и
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    с
    д
    е
    л
    к
    и
    ,
    п
    р
    а
    в
    а
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    ,
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    ы
    х
    б
    е
    з
    н
    е
    о
    б
    х
    о
    д
    и
    м
    о
    г
    о
    в
    с
    и
    л
    у
    з
    а
    к
    о
    н
    а
    с
    о
    г
    л
    а
    с
    и
    я
    т
    р
    е
    т
    ь
    е
    г
    о
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    state_expropriation -- И
    з
    ъ
    я
    т
    и
    е
    д
    л
    я
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    х
    и
    л
    и
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    н
    у
    ж
    д
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, restrictions_encumbrances_data=None, restrict_parties=None, underlying_documents=None, third_party_consents=None, state_expropriation=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.restrictions_encumbrances_data = restrictions_encumbrances_data
        self.restrictions_encumbrances_data_nsprefix_ = None
        self.restrict_parties = restrict_parties
        self.restrict_parties_nsprefix_ = None
        self.underlying_documents = underlying_documents
        self.underlying_documents_nsprefix_ = None
        self.third_party_consents = third_party_consents
        self.third_party_consents_nsprefix_ = None
        self.state_expropriation = state_expropriation
        self.state_expropriation_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictRecordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictRecordType.subclass:
            return RestrictRecordType.subclass(*args_, **kwargs_)
        else:
            return RestrictRecordType(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_restrictions_encumbrances_data(self):
        return self.restrictions_encumbrances_data
    def set_restrictions_encumbrances_data(self, restrictions_encumbrances_data):
        self.restrictions_encumbrances_data = restrictions_encumbrances_data
    def get_restrict_parties(self):
        return self.restrict_parties
    def set_restrict_parties(self, restrict_parties):
        self.restrict_parties = restrict_parties
    def get_underlying_documents(self):
        return self.underlying_documents
    def set_underlying_documents(self, underlying_documents):
        self.underlying_documents = underlying_documents
    def get_third_party_consents(self):
        return self.third_party_consents
    def set_third_party_consents(self, third_party_consents):
        self.third_party_consents = third_party_consents
    def get_state_expropriation(self):
        return self.state_expropriation
    def set_state_expropriation(self, state_expropriation):
        self.state_expropriation = state_expropriation
    def has__content(self):
        if (
            self.record_info is not None or
            self.restrictions_encumbrances_data is not None or
            self.restrict_parties is not None or
            self.underlying_documents is not None or
            self.third_party_consents is not None or
            self.state_expropriation is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictRecordType')
        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_ == 'RestrictRecordType':
            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_='RestrictRecordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictRecordType', 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_='RestrictRecordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.restrictions_encumbrances_data is not None:
            namespaceprefix_ = self.restrictions_encumbrances_data_nsprefix_ + ':' if (UseCapturedNS_ and self.restrictions_encumbrances_data_nsprefix_) else ''
            self.restrictions_encumbrances_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrictions_encumbrances_data', pretty_print=pretty_print)
        if self.restrict_parties is not None:
            namespaceprefix_ = self.restrict_parties_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_parties_nsprefix_) else ''
            self.restrict_parties.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_parties', pretty_print=pretty_print)
        if self.underlying_documents is not None:
            namespaceprefix_ = self.underlying_documents_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_documents_nsprefix_) else ''
            self.underlying_documents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_documents', pretty_print=pretty_print)
        if self.third_party_consents is not None:
            namespaceprefix_ = self.third_party_consents_nsprefix_ + ':' if (UseCapturedNS_ and self.third_party_consents_nsprefix_) else ''
            self.third_party_consents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='third_party_consents', pretty_print=pretty_print)
        if self.state_expropriation is not None:
            namespaceprefix_ = self.state_expropriation_nsprefix_ + ':' if (UseCapturedNS_ and self.state_expropriation_nsprefix_) else ''
            self.state_expropriation.export(outfile, level, namespaceprefix_, namespacedef_='', name_='state_expropriation', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RegistrationDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'restrictions_encumbrances_data':
            obj_ = RestrictionsEncumbrancesData.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrictions_encumbrances_data = obj_
            obj_.original_tagname_ = 'restrictions_encumbrances_data'
        elif nodeName_ == 'restrict_parties':
            obj_ = RestrictParties.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_parties = obj_
            obj_.original_tagname_ = 'restrict_parties'
        elif nodeName_ == 'underlying_documents':
            obj_ = UnderlyingDocumentsOutAll.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_documents = obj_
            obj_.original_tagname_ = 'underlying_documents'
        elif nodeName_ == 'third_party_consents':
            obj_ = ThirdPartyConsents.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.third_party_consents = obj_
            obj_.original_tagname_ = 'third_party_consents'
        elif nodeName_ == 'state_expropriation':
            obj_ = StateExpropriation.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.state_expropriation = obj_
            obj_.original_tagname_ = 'state_expropriation'
# end class RestrictRecordType


class AdditionalEncumbranceInfoType(GeneratedsSuper):
    """AdditionalEncumbranceInfoType -- Д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    в
    з
    а
    в
    и
    с
    и
    м
    о
    с
    т
    и
    о
    т
    в
    и
    д
    а
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    servitude -- С
    е
    р
    в
    и
    т
    у
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, servitude=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.servitude = servitude
        self.servitude_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AdditionalEncumbranceInfoType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AdditionalEncumbranceInfoType.subclass:
            return AdditionalEncumbranceInfoType.subclass(*args_, **kwargs_)
        else:
            return AdditionalEncumbranceInfoType(*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_servitude(self):
        return self.servitude
    def set_servitude(self, servitude):
        self.servitude = servitude
    def has__content(self):
        if (
            self.servitude is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AdditionalEncumbranceInfoType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AdditionalEncumbranceInfoType')
        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_ == 'AdditionalEncumbranceInfoType':
            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_='AdditionalEncumbranceInfoType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AdditionalEncumbranceInfoType', 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_='AdditionalEncumbranceInfoType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AdditionalEncumbranceInfoType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.servitude is not None:
            namespaceprefix_ = self.servitude_nsprefix_ + ':' if (UseCapturedNS_ and self.servitude_nsprefix_) else ''
            self.servitude.export(outfile, level, namespaceprefix_, namespacedef_='', name_='servitude', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'servitude':
            obj_ = ServitudeType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.servitude = obj_
            obj_.original_tagname_ = 'servitude'
# end class AdditionalEncumbranceInfoType


class ServitudeType(GeneratedsSuper):
    """ServitudeType -- С
    е
    р
    в
    и
    т
    у
    т
    servitude_kind -- В
    и
    д
    с
    е
    р
    в
    и
    т
    у
    т
    а
    servitude_condition -- У
    с
    л
    о
    в
    и
    я
    с
    е
    р
    в
    и
    т
    у
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, servitude_kind=None, servitude_condition=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.servitude_kind = servitude_kind
        self.servitude_kind_nsprefix_ = None
        self.servitude_condition = servitude_condition
        self.validate_MultiLiner(self.servitude_condition)
        self.servitude_condition_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ServitudeType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ServitudeType.subclass:
            return ServitudeType.subclass(*args_, **kwargs_)
        else:
            return ServitudeType(*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_servitude_kind(self):
        return self.servitude_kind
    def set_servitude_kind(self, servitude_kind):
        self.servitude_kind = servitude_kind
    def get_servitude_condition(self):
        return self.servitude_condition
    def set_servitude_condition(self, servitude_condition):
        self.servitude_condition = servitude_condition
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.servitude_kind is not None or
            self.servitude_condition is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ServitudeType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ServitudeType')
        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_ == 'ServitudeType':
            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_='ServitudeType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ServitudeType', 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_='ServitudeType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ServitudeType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.servitude_kind is not None:
            namespaceprefix_ = self.servitude_kind_nsprefix_ + ':' if (UseCapturedNS_ and self.servitude_kind_nsprefix_) else ''
            self.servitude_kind.export(outfile, level, namespaceprefix_, namespacedef_='', name_='servitude_kind', pretty_print=pretty_print)
        if self.servitude_condition is not None:
            namespaceprefix_ = self.servitude_condition_nsprefix_ + ':' if (UseCapturedNS_ and self.servitude_condition_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sservitude_condition>%s</%sservitude_condition>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.servitude_condition), input_name='servitude_condition')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'servitude_kind':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.servitude_kind = obj_
            obj_.original_tagname_ = 'servitude_kind'
        elif nodeName_ == 'servitude_condition':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'servitude_condition')
            value_ = self.gds_validate_string(value_, node, 'servitude_condition')
            self.servitude_condition = value_
            self.servitude_condition_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.servitude_condition)
# end class ServitudeType


class RestrictRecordsBaseParamsLand(GeneratedsSuper):
    """RestrictRecordsBaseParamsLand -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restrict_record -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restrict_record=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 restrict_record is None:
            self.restrict_record = []
        else:
            self.restrict_record = restrict_record
        self.restrict_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictRecordsBaseParamsLand)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictRecordsBaseParamsLand.subclass:
            return RestrictRecordsBaseParamsLand.subclass(*args_, **kwargs_)
        else:
            return RestrictRecordsBaseParamsLand(*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_restrict_record(self):
        return self.restrict_record
    def set_restrict_record(self, restrict_record):
        self.restrict_record = restrict_record
    def add_restrict_record(self, value):
        self.restrict_record.append(value)
    def insert_restrict_record_at(self, index, value):
        self.restrict_record.insert(index, value)
    def replace_restrict_record_at(self, index, value):
        self.restrict_record[index] = value
    def has__content(self):
        if (
            self.restrict_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordsBaseParamsLand', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictRecordsBaseParamsLand')
        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_ == 'RestrictRecordsBaseParamsLand':
            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_='RestrictRecordsBaseParamsLand')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictRecordsBaseParamsLand', 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_='RestrictRecordsBaseParamsLand'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordsBaseParamsLand', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restrict_record_ in self.restrict_record:
            namespaceprefix_ = self.restrict_record_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_record_nsprefix_) else ''
            restrict_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restrict_record':
            obj_ = RestrictRecordLandType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_record.append(obj_)
            obj_.original_tagname_ = 'restrict_record'
# end class RestrictRecordsBaseParamsLand


class RestrictRecordLandType(GeneratedsSuper):
    """RestrictRecordLandType -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    record_info -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    restrictions_encumbrances_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    restrict_parties -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    а
    х
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    ,
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    underlying_documents -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    third_party_consents -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    е
    н
    и
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    с
    д
    е
    л
    к
    и
    ,
    п
    р
    а
    в
    а
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    ,
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    ы
    х
    б
    е
    з
    н
    е
    о
    б
    х
    о
    д
    и
    м
    о
    г
    о
    в
    с
    и
    л
    у
    з
    а
    к
    о
    н
    а
    с
    о
    г
    л
    а
    с
    и
    я
    т
    р
    е
    т
    ь
    е
    г
    о
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, restrictions_encumbrances_data=None, restrict_parties=None, underlying_documents=None, third_party_consents=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.restrictions_encumbrances_data = restrictions_encumbrances_data
        self.restrictions_encumbrances_data_nsprefix_ = None
        self.restrict_parties = restrict_parties
        self.restrict_parties_nsprefix_ = None
        self.underlying_documents = underlying_documents
        self.underlying_documents_nsprefix_ = None
        self.third_party_consents = third_party_consents
        self.third_party_consents_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictRecordLandType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictRecordLandType.subclass:
            return RestrictRecordLandType.subclass(*args_, **kwargs_)
        else:
            return RestrictRecordLandType(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_restrictions_encumbrances_data(self):
        return self.restrictions_encumbrances_data
    def set_restrictions_encumbrances_data(self, restrictions_encumbrances_data):
        self.restrictions_encumbrances_data = restrictions_encumbrances_data
    def get_restrict_parties(self):
        return self.restrict_parties
    def set_restrict_parties(self, restrict_parties):
        self.restrict_parties = restrict_parties
    def get_underlying_documents(self):
        return self.underlying_documents
    def set_underlying_documents(self, underlying_documents):
        self.underlying_documents = underlying_documents
    def get_third_party_consents(self):
        return self.third_party_consents
    def set_third_party_consents(self, third_party_consents):
        self.third_party_consents = third_party_consents
    def has__content(self):
        if (
            self.record_info is not None or
            self.restrictions_encumbrances_data is not None or
            self.restrict_parties is not None or
            self.underlying_documents is not None or
            self.third_party_consents is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordLandType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictRecordLandType')
        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_ == 'RestrictRecordLandType':
            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_='RestrictRecordLandType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictRecordLandType', 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_='RestrictRecordLandType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordLandType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.restrictions_encumbrances_data is not None:
            namespaceprefix_ = self.restrictions_encumbrances_data_nsprefix_ + ':' if (UseCapturedNS_ and self.restrictions_encumbrances_data_nsprefix_) else ''
            self.restrictions_encumbrances_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrictions_encumbrances_data', pretty_print=pretty_print)
        if self.restrict_parties is not None:
            namespaceprefix_ = self.restrict_parties_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_parties_nsprefix_) else ''
            self.restrict_parties.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_parties', pretty_print=pretty_print)
        if self.underlying_documents is not None:
            namespaceprefix_ = self.underlying_documents_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_documents_nsprefix_) else ''
            self.underlying_documents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_documents', pretty_print=pretty_print)
        if self.third_party_consents is not None:
            namespaceprefix_ = self.third_party_consents_nsprefix_ + ':' if (UseCapturedNS_ and self.third_party_consents_nsprefix_) else ''
            self.third_party_consents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='third_party_consents', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RegistrationDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'restrictions_encumbrances_data':
            obj_ = RestrictionsEncumbrancesDataLand.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrictions_encumbrances_data = obj_
            obj_.original_tagname_ = 'restrictions_encumbrances_data'
        elif nodeName_ == 'restrict_parties':
            obj_ = RestrictParties.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_parties = obj_
            obj_.original_tagname_ = 'restrict_parties'
        elif nodeName_ == 'underlying_documents':
            obj_ = UnderlyingDocumentsOutAll.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_documents = obj_
            obj_.original_tagname_ = 'underlying_documents'
        elif nodeName_ == 'third_party_consents':
            obj_ = ThirdPartyConsents.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.third_party_consents = obj_
            obj_.original_tagname_ = 'third_party_consents'
# end class RestrictRecordLandType


class RestrictionsEncumbrancesData(GeneratedsSuper):
    """RestrictionsEncumbrancesData -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    о
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    ы
    е
    п
    р
    а
    в
    а
    ,
    о
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    ы
    е
    с
    д
    е
    л
    к
    и
    )
    restriction_encumbrance_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restriction_encumbrance_type -- В
    и
    д
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    period -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    additional_encumbrance_info -- Д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    в
    з
    а
    в
    и
    с
    и
    м
    о
    с
    т
    и
    о
    т
    в
    и
    д
    а
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restricting_rights -- О
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    ы
    е
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restriction_encumbrance_number=None, restriction_encumbrance_type=None, period=None, additional_encumbrance_info=None, restricting_rights=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.restriction_encumbrance_number = restriction_encumbrance_number
        self.restriction_encumbrance_number_nsprefix_ = None
        self.restriction_encumbrance_type = restriction_encumbrance_type
        self.restriction_encumbrance_type_nsprefix_ = None
        self.period = period
        self.period_nsprefix_ = None
        self.additional_encumbrance_info = additional_encumbrance_info
        self.additional_encumbrance_info_nsprefix_ = None
        self.restricting_rights = restricting_rights
        self.restricting_rights_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictionsEncumbrancesData)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictionsEncumbrancesData.subclass:
            return RestrictionsEncumbrancesData.subclass(*args_, **kwargs_)
        else:
            return RestrictionsEncumbrancesData(*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_restriction_encumbrance_number(self):
        return self.restriction_encumbrance_number
    def set_restriction_encumbrance_number(self, restriction_encumbrance_number):
        self.restriction_encumbrance_number = restriction_encumbrance_number
    def get_restriction_encumbrance_type(self):
        return self.restriction_encumbrance_type
    def set_restriction_encumbrance_type(self, restriction_encumbrance_type):
        self.restriction_encumbrance_type = restriction_encumbrance_type
    def get_period(self):
        return self.period
    def set_period(self, period):
        self.period = period
    def get_additional_encumbrance_info(self):
        return self.additional_encumbrance_info
    def set_additional_encumbrance_info(self, additional_encumbrance_info):
        self.additional_encumbrance_info = additional_encumbrance_info
    def get_restricting_rights(self):
        return self.restricting_rights
    def set_restricting_rights(self, restricting_rights):
        self.restricting_rights = restricting_rights
    def has__content(self):
        if (
            self.restriction_encumbrance_number is not None or
            self.restriction_encumbrance_type is not None or
            self.period is not None or
            self.additional_encumbrance_info is not None or
            self.restricting_rights is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictionsEncumbrancesData', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictionsEncumbrancesData')
        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_ == 'RestrictionsEncumbrancesData':
            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_='RestrictionsEncumbrancesData')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictionsEncumbrancesData', 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_='RestrictionsEncumbrancesData'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictionsEncumbrancesData', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.restriction_encumbrance_number is not None:
            namespaceprefix_ = self.restriction_encumbrance_number_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%srestriction_encumbrance_number>%s</%srestriction_encumbrance_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.restriction_encumbrance_number), input_name='restriction_encumbrance_number')), namespaceprefix_ , eol_))
        if self.restriction_encumbrance_type is not None:
            namespaceprefix_ = self.restriction_encumbrance_type_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_type_nsprefix_) else ''
            self.restriction_encumbrance_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restriction_encumbrance_type', pretty_print=pretty_print)
        if self.period is not None:
            namespaceprefix_ = self.period_nsprefix_ + ':' if (UseCapturedNS_ and self.period_nsprefix_) else ''
            self.period.export(outfile, level, namespaceprefix_, namespacedef_='', name_='period', pretty_print=pretty_print)
        if self.additional_encumbrance_info is not None:
            namespaceprefix_ = self.additional_encumbrance_info_nsprefix_ + ':' if (UseCapturedNS_ and self.additional_encumbrance_info_nsprefix_) else ''
            self.additional_encumbrance_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='additional_encumbrance_info', pretty_print=pretty_print)
        if self.restricting_rights is not None:
            namespaceprefix_ = self.restricting_rights_nsprefix_ + ':' if (UseCapturedNS_ and self.restricting_rights_nsprefix_) else ''
            self.restricting_rights.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restricting_rights', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restriction_encumbrance_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'restriction_encumbrance_number')
            value_ = self.gds_validate_string(value_, node, 'restriction_encumbrance_number')
            self.restriction_encumbrance_number = value_
            self.restriction_encumbrance_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'restriction_encumbrance_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restriction_encumbrance_type = obj_
            obj_.original_tagname_ = 'restriction_encumbrance_type'
        elif nodeName_ == 'period':
            obj_ = PeriodType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.period = obj_
            obj_.original_tagname_ = 'period'
        elif nodeName_ == 'additional_encumbrance_info':
            obj_ = AdditionalEncumbranceInfoType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.additional_encumbrance_info = obj_
            obj_.original_tagname_ = 'additional_encumbrance_info'
        elif nodeName_ == 'restricting_rights':
            obj_ = RestrictingRightsAllNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restricting_rights = obj_
            obj_.original_tagname_ = 'restricting_rights'
# end class RestrictionsEncumbrancesData


class RestrictionsEncumbrancesDataLand(GeneratedsSuper):
    """RestrictionsEncumbrancesDataLand -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    о
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    ы
    е
    п
    р
    а
    в
    а
    ,
    о
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    ы
    е
    с
    д
    е
    л
    к
    и
    )
    restriction_encumbrance_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restriction_encumbrance_type -- В
    и
    д
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    period -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    additional_encumbrance_info -- Д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    в
    з
    а
    в
    и
    с
    и
    м
    о
    с
    т
    и
    о
    т
    в
    и
    д
    а
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restricting_rights -- О
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    ы
    е
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restriction_encumbrance_number=None, restriction_encumbrance_type=None, period=None, additional_encumbrance_info=None, restricting_rights=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.restriction_encumbrance_number = restriction_encumbrance_number
        self.restriction_encumbrance_number_nsprefix_ = None
        self.restriction_encumbrance_type = restriction_encumbrance_type
        self.restriction_encumbrance_type_nsprefix_ = None
        self.period = period
        self.period_nsprefix_ = None
        self.additional_encumbrance_info = additional_encumbrance_info
        self.additional_encumbrance_info_nsprefix_ = None
        self.restricting_rights = restricting_rights
        self.restricting_rights_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictionsEncumbrancesDataLand)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictionsEncumbrancesDataLand.subclass:
            return RestrictionsEncumbrancesDataLand.subclass(*args_, **kwargs_)
        else:
            return RestrictionsEncumbrancesDataLand(*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_restriction_encumbrance_number(self):
        return self.restriction_encumbrance_number
    def set_restriction_encumbrance_number(self, restriction_encumbrance_number):
        self.restriction_encumbrance_number = restriction_encumbrance_number
    def get_restriction_encumbrance_type(self):
        return self.restriction_encumbrance_type
    def set_restriction_encumbrance_type(self, restriction_encumbrance_type):
        self.restriction_encumbrance_type = restriction_encumbrance_type
    def get_period(self):
        return self.period
    def set_period(self, period):
        self.period = period
    def get_additional_encumbrance_info(self):
        return self.additional_encumbrance_info
    def set_additional_encumbrance_info(self, additional_encumbrance_info):
        self.additional_encumbrance_info = additional_encumbrance_info
    def get_restricting_rights(self):
        return self.restricting_rights
    def set_restricting_rights(self, restricting_rights):
        self.restricting_rights = restricting_rights
    def has__content(self):
        if (
            self.restriction_encumbrance_number is not None or
            self.restriction_encumbrance_type is not None or
            self.period is not None or
            self.additional_encumbrance_info is not None or
            self.restricting_rights is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictionsEncumbrancesDataLand', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictionsEncumbrancesDataLand')
        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_ == 'RestrictionsEncumbrancesDataLand':
            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_='RestrictionsEncumbrancesDataLand')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictionsEncumbrancesDataLand', 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_='RestrictionsEncumbrancesDataLand'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictionsEncumbrancesDataLand', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.restriction_encumbrance_number is not None:
            namespaceprefix_ = self.restriction_encumbrance_number_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%srestriction_encumbrance_number>%s</%srestriction_encumbrance_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.restriction_encumbrance_number), input_name='restriction_encumbrance_number')), namespaceprefix_ , eol_))
        if self.restriction_encumbrance_type is not None:
            namespaceprefix_ = self.restriction_encumbrance_type_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_type_nsprefix_) else ''
            self.restriction_encumbrance_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restriction_encumbrance_type', pretty_print=pretty_print)
        if self.period is not None:
            namespaceprefix_ = self.period_nsprefix_ + ':' if (UseCapturedNS_ and self.period_nsprefix_) else ''
            self.period.export(outfile, level, namespaceprefix_, namespacedef_='', name_='period', pretty_print=pretty_print)
        if self.additional_encumbrance_info is not None:
            namespaceprefix_ = self.additional_encumbrance_info_nsprefix_ + ':' if (UseCapturedNS_ and self.additional_encumbrance_info_nsprefix_) else ''
            self.additional_encumbrance_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='additional_encumbrance_info', pretty_print=pretty_print)
        if self.restricting_rights is not None:
            namespaceprefix_ = self.restricting_rights_nsprefix_ + ':' if (UseCapturedNS_ and self.restricting_rights_nsprefix_) else ''
            self.restricting_rights.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restricting_rights', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restriction_encumbrance_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'restriction_encumbrance_number')
            value_ = self.gds_validate_string(value_, node, 'restriction_encumbrance_number')
            self.restriction_encumbrance_number = value_
            self.restriction_encumbrance_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'restriction_encumbrance_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restriction_encumbrance_type = obj_
            obj_.original_tagname_ = 'restriction_encumbrance_type'
        elif nodeName_ == 'period':
            obj_ = PeriodTypeLand.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.period = obj_
            obj_.original_tagname_ = 'period'
        elif nodeName_ == 'additional_encumbrance_info':
            obj_ = AdditionalEncumbranceInfoType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.additional_encumbrance_info = obj_
            obj_.original_tagname_ = 'additional_encumbrance_info'
        elif nodeName_ == 'restricting_rights':
            obj_ = RestrictingRightsAllNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restricting_rights = obj_
            obj_.original_tagname_ = 'restricting_rights'
# end class RestrictionsEncumbrancesDataLand


class PeriodType(GeneratedsSuper):
    """PeriodType -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    period_info -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, period_info=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.period_info = period_info
        self.period_info_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PeriodType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PeriodType.subclass:
            return PeriodType.subclass(*args_, **kwargs_)
        else:
            return PeriodType(*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_period_info(self):
        return self.period_info
    def set_period_info(self, period_info):
        self.period_info = period_info
    def has__content(self):
        if (
            self.period_info is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PeriodType')
        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_ == 'PeriodType':
            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_='PeriodType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PeriodType', 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_='PeriodType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.period_info is not None:
            namespaceprefix_ = self.period_info_nsprefix_ + ':' if (UseCapturedNS_ and self.period_info_nsprefix_) else ''
            self.period_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='period_info', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'period_info':
            obj_ = PeriodInfoType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.period_info = obj_
            obj_.original_tagname_ = 'period_info'
# end class PeriodType


class PeriodTypeLand(GeneratedsSuper):
    """PeriodTypeLand -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    period_info -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    period_ddu -- С
    р
    о
    к
    д
    л
    я
    и
    п
    о
    т
    е
    к
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    ,
    н
    а
    к
    о
    т
    о
    р
    о
    м
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    я
    е
    т
    с
    я
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    о
    м
    н
    о
    г
    о
    к
    в
    а
    р
    т
    и
    р
    н
    о
    г
    о
    д
    о
    м
    а
    и
    (
    и
    л
    и
    )
    и
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    и
    м
    у
    щ
    е
    с
    т
    в
    а
    ,
    в
    о
    з
    н
    и
    к
    ш
    е
    й
    н
    а
    о
    с
    н
    о
    в
    а
    н
    и
    и
    з
    а
    к
    о
    н
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, period_info=None, period_ddu=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.period_info = period_info
        self.period_info_nsprefix_ = None
        self.period_ddu = period_ddu
        self.period_ddu_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PeriodTypeLand)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PeriodTypeLand.subclass:
            return PeriodTypeLand.subclass(*args_, **kwargs_)
        else:
            return PeriodTypeLand(*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_period_info(self):
        return self.period_info
    def set_period_info(self, period_info):
        self.period_info = period_info
    def get_period_ddu(self):
        return self.period_ddu
    def set_period_ddu(self, period_ddu):
        self.period_ddu = period_ddu
    def has__content(self):
        if (
            self.period_info is not None or
            self.period_ddu is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodTypeLand', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PeriodTypeLand')
        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_ == 'PeriodTypeLand':
            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_='PeriodTypeLand')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PeriodTypeLand', 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_='PeriodTypeLand'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodTypeLand', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.period_info is not None:
            namespaceprefix_ = self.period_info_nsprefix_ + ':' if (UseCapturedNS_ and self.period_info_nsprefix_) else ''
            self.period_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='period_info', pretty_print=pretty_print)
        if self.period_ddu is not None:
            namespaceprefix_ = self.period_ddu_nsprefix_ + ':' if (UseCapturedNS_ and self.period_ddu_nsprefix_) else ''
            self.period_ddu.export(outfile, level, namespaceprefix_, namespacedef_='', name_='period_ddu', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'period_info':
            obj_ = PeriodInfoType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.period_info = obj_
            obj_.original_tagname_ = 'period_info'
        elif nodeName_ == 'period_ddu':
            obj_ = PeriodDDU.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.period_ddu = obj_
            obj_.original_tagname_ = 'period_ddu'
# end class PeriodTypeLand


class PeriodDDU(GeneratedsSuper):
    """PeriodDDU -- С
    р
    о
    к
    д
    л
    я
    и
    п
    о
    т
    е
    к
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    ,
    н
    а
    к
    о
    т
    о
    р
    о
    м
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    я
    е
    т
    с
    я
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    о
    м
    н
    о
    г
    о
    к
    в
    а
    р
    т
    и
    р
    н
    о
    г
    о
    д
    о
    м
    а
    и
    (
    и
    л
    и
    )
    и
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    и
    м
    у
    щ
    е
    с
    т
    в
    а
    ,
    в
    о
    з
    н
    и
    к
    ш
    е
    й
    н
    а
    о
    с
    н
    о
    в
    а
    н
    и
    и
    з
    а
    к
    о
    н
    а
    first_ddu_date -- Д
    а
    т
    а
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    е
    р
    в
    о
    г
    о
    Д
    Д
    У
    transfer_deadline -- С
    р
    о
    к
    п
    е
    р
    е
    д
    а
    ч
    и
    з
    а
    с
    т
    р
    о
    й
    щ
    и
    к
    о
    м
    о
    б
    ъ
    е
    к
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, first_ddu_date=None, transfer_deadline=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(first_ddu_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(first_ddu_date, '%Y-%m-%d').date()
        else:
            initvalue_ = first_ddu_date
        self.first_ddu_date = initvalue_
        self.first_ddu_date_nsprefix_ = None
        self.transfer_deadline = transfer_deadline
        self.transfer_deadline_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PeriodDDU)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PeriodDDU.subclass:
            return PeriodDDU.subclass(*args_, **kwargs_)
        else:
            return PeriodDDU(*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_first_ddu_date(self):
        return self.first_ddu_date
    def set_first_ddu_date(self, first_ddu_date):
        self.first_ddu_date = first_ddu_date
    def get_transfer_deadline(self):
        return self.transfer_deadline
    def set_transfer_deadline(self, transfer_deadline):
        self.transfer_deadline = transfer_deadline
    def has__content(self):
        if (
            self.first_ddu_date is not None or
            self.transfer_deadline is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodDDU', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PeriodDDU')
        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_ == 'PeriodDDU':
            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_='PeriodDDU')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PeriodDDU', 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_='PeriodDDU'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodDDU', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.first_ddu_date is not None:
            namespaceprefix_ = self.first_ddu_date_nsprefix_ + ':' if (UseCapturedNS_ and self.first_ddu_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfirst_ddu_date>%s</%sfirst_ddu_date>%s' % (namespaceprefix_ , self.gds_format_date(self.first_ddu_date, input_name='first_ddu_date'), namespaceprefix_ , eol_))
        if self.transfer_deadline is not None:
            namespaceprefix_ = self.transfer_deadline_nsprefix_ + ':' if (UseCapturedNS_ and self.transfer_deadline_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stransfer_deadline>%s</%stransfer_deadline>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.transfer_deadline), input_name='transfer_deadline')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'first_ddu_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.first_ddu_date = dval_
            self.first_ddu_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'transfer_deadline':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'transfer_deadline')
            value_ = self.gds_validate_string(value_, node, 'transfer_deadline')
            self.transfer_deadline = value_
            self.transfer_deadline_nsprefix_ = child_.prefix
# end class PeriodDDU


class PeriodInfoType(GeneratedsSuper):
    """PeriodInfoType -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    start_date -- Д
    а
    т
    а
    н
    а
    ч
    а
    л
    а
    д
    е
    й
    с
    т
    в
    и
    я
    end_date -- Д
    а
    т
    а
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    я
    д
    е
    й
    с
    т
    в
    и
    я
    deal_validity_time -- С
    р
    о
    к
    д
    е
    й
    с
    т
    в
    и
    я
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    /
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    (
    П
    р
    о
    д
    о
    л
    ж
    и
    т
    е
    л
    ь
    н
    о
    с
    т
    ь
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, start_date=None, end_date=None, deal_validity_time=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(start_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(start_date, '%Y-%m-%d').date()
        else:
            initvalue_ = start_date
        self.start_date = initvalue_
        self.start_date_nsprefix_ = None
        if isinstance(end_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(end_date, '%Y-%m-%d').date()
        else:
            initvalue_ = end_date
        self.end_date = initvalue_
        self.end_date_nsprefix_ = None
        self.deal_validity_time = deal_validity_time
        self.deal_validity_time_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PeriodInfoType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PeriodInfoType.subclass:
            return PeriodInfoType.subclass(*args_, **kwargs_)
        else:
            return PeriodInfoType(*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_start_date(self):
        return self.start_date
    def set_start_date(self, start_date):
        self.start_date = start_date
    def get_end_date(self):
        return self.end_date
    def set_end_date(self, end_date):
        self.end_date = end_date
    def get_deal_validity_time(self):
        return self.deal_validity_time
    def set_deal_validity_time(self, deal_validity_time):
        self.deal_validity_time = deal_validity_time
    def has__content(self):
        if (
            self.start_date is not None or
            self.end_date is not None or
            self.deal_validity_time is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodInfoType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PeriodInfoType')
        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_ == 'PeriodInfoType':
            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_='PeriodInfoType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PeriodInfoType', 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_='PeriodInfoType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PeriodInfoType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.start_date is not None:
            namespaceprefix_ = self.start_date_nsprefix_ + ':' if (UseCapturedNS_ and self.start_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sstart_date>%s</%sstart_date>%s' % (namespaceprefix_ , self.gds_format_date(self.start_date, input_name='start_date'), namespaceprefix_ , eol_))
        if self.end_date is not None:
            namespaceprefix_ = self.end_date_nsprefix_ + ':' if (UseCapturedNS_ and self.end_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%send_date>%s</%send_date>%s' % (namespaceprefix_ , self.gds_format_date(self.end_date, input_name='end_date'), namespaceprefix_ , eol_))
        if self.deal_validity_time is not None:
            namespaceprefix_ = self.deal_validity_time_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_validity_time_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdeal_validity_time>%s</%sdeal_validity_time>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.deal_validity_time), input_name='deal_validity_time')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'start_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.start_date = dval_
            self.start_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'end_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.end_date = dval_
            self.end_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'deal_validity_time':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'deal_validity_time')
            value_ = self.gds_validate_string(value_, node, 'deal_validity_time')
            self.deal_validity_time = value_
            self.deal_validity_time_nsprefix_ = child_.prefix
# end class PeriodInfoType


class RestrictingRights(GeneratedsSuper):
    """RestrictingRights -- О
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    ы
    е
    п
    р
    а
    в
    а
    restricting_right -- О
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    о
    е
    п
    р
    а
    в
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restricting_right=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 restricting_right is None:
            self.restricting_right = []
        else:
            self.restricting_right = restricting_right
        self.restricting_right_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictingRights)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictingRights.subclass:
            return RestrictingRights.subclass(*args_, **kwargs_)
        else:
            return RestrictingRights(*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_restricting_right(self):
        return self.restricting_right
    def set_restricting_right(self, restricting_right):
        self.restricting_right = restricting_right
    def add_restricting_right(self, value):
        self.restricting_right.append(value)
    def insert_restricting_right_at(self, index, value):
        self.restricting_right.insert(index, value)
    def replace_restricting_right_at(self, index, value):
        self.restricting_right[index] = value
    def has__content(self):
        if (
            self.restricting_right
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictingRights', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictingRights')
        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_ == 'RestrictingRights':
            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_='RestrictingRights')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictingRights', 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_='RestrictingRights'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictingRights', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restricting_right_ in self.restricting_right:
            namespaceprefix_ = self.restricting_right_nsprefix_ + ':' if (UseCapturedNS_ and self.restricting_right_nsprefix_) else ''
            restricting_right_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restricting_right', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restricting_right':
            obj_ = RightNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restricting_right.append(obj_)
            obj_.original_tagname_ = 'restricting_right'
# end class RestrictingRights


class RestrictingRightsAllNumber(GeneratedsSuper):
    """RestrictingRightsAllNumber -- О
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    ы
    е
    п
    р
    а
    в
    а
    restricting_right -- О
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    о
    е
    п
    р
    а
    в
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restricting_right=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 restricting_right is None:
            self.restricting_right = []
        else:
            self.restricting_right = restricting_right
        self.restricting_right_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictingRightsAllNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictingRightsAllNumber.subclass:
            return RestrictingRightsAllNumber.subclass(*args_, **kwargs_)
        else:
            return RestrictingRightsAllNumber(*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_restricting_right(self):
        return self.restricting_right
    def set_restricting_right(self, restricting_right):
        self.restricting_right = restricting_right
    def add_restricting_right(self, value):
        self.restricting_right.append(value)
    def insert_restricting_right_at(self, index, value):
        self.restricting_right.insert(index, value)
    def replace_restricting_right_at(self, index, value):
        self.restricting_right[index] = value
    def has__content(self):
        if (
            self.restricting_right
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictingRightsAllNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictingRightsAllNumber')
        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_ == 'RestrictingRightsAllNumber':
            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_='RestrictingRightsAllNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictingRightsAllNumber', 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_='RestrictingRightsAllNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictingRightsAllNumber', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restricting_right_ in self.restricting_right:
            namespaceprefix_ = self.restricting_right_nsprefix_ + ':' if (UseCapturedNS_ and self.restricting_right_nsprefix_) else ''
            restricting_right_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restricting_right', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restricting_right':
            obj_ = RightRecordNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restricting_right.append(obj_)
            obj_.original_tagname_ = 'restricting_right'
# end class RestrictingRightsAllNumber


class RestrictingDealsAllNumber(GeneratedsSuper):
    """RestrictingDealsAllNumber -- О
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    ы
    е
    с
    д
    е
    л
    к
    и
    restricting_deal -- О
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    е
    м
    а
    я
    с
    д
    е
    л
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restricting_deal=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 restricting_deal is None:
            self.restricting_deal = []
        else:
            self.restricting_deal = restricting_deal
        self.restricting_deal_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictingDealsAllNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictingDealsAllNumber.subclass:
            return RestrictingDealsAllNumber.subclass(*args_, **kwargs_)
        else:
            return RestrictingDealsAllNumber(*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_restricting_deal(self):
        return self.restricting_deal
    def set_restricting_deal(self, restricting_deal):
        self.restricting_deal = restricting_deal
    def add_restricting_deal(self, value):
        self.restricting_deal.append(value)
    def insert_restricting_deal_at(self, index, value):
        self.restricting_deal.insert(index, value)
    def replace_restricting_deal_at(self, index, value):
        self.restricting_deal[index] = value
    def has__content(self):
        if (
            self.restricting_deal
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictingDealsAllNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictingDealsAllNumber')
        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_ == 'RestrictingDealsAllNumber':
            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_='RestrictingDealsAllNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictingDealsAllNumber', 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_='RestrictingDealsAllNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictingDealsAllNumber', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restricting_deal_ in self.restricting_deal:
            namespaceprefix_ = self.restricting_deal_nsprefix_ + ':' if (UseCapturedNS_ and self.restricting_deal_nsprefix_) else ''
            restricting_deal_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restricting_deal', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restricting_deal':
            obj_ = DealRecordNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restricting_deal.append(obj_)
            obj_.original_tagname_ = 'restricting_deal'
# end class RestrictingDealsAllNumber


class RestrictionsEncumbrances(GeneratedsSuper):
    """RestrictionsEncumbrances -- Н
    е
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    ы
    е
    и
    н
    е
    п
    о
    д
    л
    е
    ж
    а
    щ
    и
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    (
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    )
    restriction_encumbrance -- Н
    е
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    е
    и
    н
    е
    п
    о
    д
    л
    е
    ж
    а
    щ
    е
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    (
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restriction_encumbrance=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 restriction_encumbrance is None:
            self.restriction_encumbrance = []
        else:
            self.restriction_encumbrance = restriction_encumbrance
        self.restriction_encumbrance_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictionsEncumbrances)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictionsEncumbrances.subclass:
            return RestrictionsEncumbrances.subclass(*args_, **kwargs_)
        else:
            return RestrictionsEncumbrances(*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_restriction_encumbrance(self):
        return self.restriction_encumbrance
    def set_restriction_encumbrance(self, restriction_encumbrance):
        self.restriction_encumbrance = restriction_encumbrance
    def add_restriction_encumbrance(self, value):
        self.restriction_encumbrance.append(value)
    def insert_restriction_encumbrance_at(self, index, value):
        self.restriction_encumbrance.insert(index, value)
    def replace_restriction_encumbrance_at(self, index, value):
        self.restriction_encumbrance[index] = value
    def has__content(self):
        if (
            self.restriction_encumbrance
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictionsEncumbrances', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictionsEncumbrances')
        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_ == 'RestrictionsEncumbrances':
            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_='RestrictionsEncumbrances')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictionsEncumbrances', 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_='RestrictionsEncumbrances'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictionsEncumbrances', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restriction_encumbrance_ in self.restriction_encumbrance:
            namespaceprefix_ = self.restriction_encumbrance_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_nsprefix_) else ''
            restriction_encumbrance_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restriction_encumbrance', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restriction_encumbrance':
            obj_ = restriction_encumbranceType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restriction_encumbrance.append(obj_)
            obj_.original_tagname_ = 'restriction_encumbrance'
# end class RestrictionsEncumbrances


class RestrictionsEncumbrancesNoPart(GeneratedsSuper):
    """RestrictionsEncumbrancesNoPart -- Н
    е
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    ы
    е
    и
    н
    е
    п
    о
    д
    л
    е
    ж
    а
    щ
    и
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    (
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    )
    restriction_encumbrance -- Н
    е
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    е
    и
    н
    е
    п
    о
    д
    л
    е
    ж
    а
    щ
    е
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    (
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restriction_encumbrance=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 restriction_encumbrance is None:
            self.restriction_encumbrance = []
        else:
            self.restriction_encumbrance = restriction_encumbrance
        self.restriction_encumbrance_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictionsEncumbrancesNoPart)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictionsEncumbrancesNoPart.subclass:
            return RestrictionsEncumbrancesNoPart.subclass(*args_, **kwargs_)
        else:
            return RestrictionsEncumbrancesNoPart(*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_restriction_encumbrance(self):
        return self.restriction_encumbrance
    def set_restriction_encumbrance(self, restriction_encumbrance):
        self.restriction_encumbrance = restriction_encumbrance
    def add_restriction_encumbrance(self, value):
        self.restriction_encumbrance.append(value)
    def insert_restriction_encumbrance_at(self, index, value):
        self.restriction_encumbrance.insert(index, value)
    def replace_restriction_encumbrance_at(self, index, value):
        self.restriction_encumbrance[index] = value
    def has__content(self):
        if (
            self.restriction_encumbrance
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictionsEncumbrancesNoPart', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictionsEncumbrancesNoPart')
        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_ == 'RestrictionsEncumbrancesNoPart':
            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_='RestrictionsEncumbrancesNoPart')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictionsEncumbrancesNoPart', 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_='RestrictionsEncumbrancesNoPart'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictionsEncumbrancesNoPart', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restriction_encumbrance_ in self.restriction_encumbrance:
            namespaceprefix_ = self.restriction_encumbrance_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_nsprefix_) else ''
            restriction_encumbrance_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restriction_encumbrance', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restriction_encumbrance':
            obj_ = restriction_encumbranceType8.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restriction_encumbrance.append(obj_)
            obj_.original_tagname_ = 'restriction_encumbrance'
# end class RestrictionsEncumbrancesNoPart


class ContentRestrictions(GeneratedsSuper):
    """ContentRestrictions -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    й
    (
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    ы
    х
    )
    data_registration -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    reg_numb_border -- Р
    е
    е
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    г
    р
    а
    н
    и
    ц
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, data_registration=None, reg_numb_border=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.data_registration = data_registration
        self.data_registration_nsprefix_ = None
        self.reg_numb_border = reg_numb_border
        self.reg_numb_border_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContentRestrictions)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContentRestrictions.subclass:
            return ContentRestrictions.subclass(*args_, **kwargs_)
        else:
            return ContentRestrictions(*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_data_registration(self):
        return self.data_registration
    def set_data_registration(self, data_registration):
        self.data_registration = data_registration
    def get_reg_numb_border(self):
        return self.reg_numb_border
    def set_reg_numb_border(self, reg_numb_border):
        self.reg_numb_border = reg_numb_border
    def has__content(self):
        if (
            self.data_registration is not None or
            self.reg_numb_border is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContentRestrictions', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContentRestrictions')
        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_ == 'ContentRestrictions':
            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_='ContentRestrictions')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContentRestrictions', 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_='ContentRestrictions'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContentRestrictions', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.data_registration is not None:
            namespaceprefix_ = self.data_registration_nsprefix_ + ':' if (UseCapturedNS_ and self.data_registration_nsprefix_) else ''
            self.data_registration.export(outfile, level, namespaceprefix_, namespacedef_='', name_='data_registration', pretty_print=pretty_print)
        if self.reg_numb_border is not None:
            namespaceprefix_ = self.reg_numb_border_nsprefix_ + ':' if (UseCapturedNS_ and self.reg_numb_border_nsprefix_) else ''
            self.reg_numb_border.export(outfile, level, namespaceprefix_, namespacedef_='', name_='reg_numb_border', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'data_registration':
            obj_ = Registration.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.data_registration = obj_
            obj_.original_tagname_ = 'data_registration'
        elif nodeName_ == 'reg_numb_border':
            obj_ = RegNumberBorder.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.reg_numb_border = obj_
            obj_.original_tagname_ = 'reg_numb_border'
# end class ContentRestrictions


class RestrictRecordsIndivid(GeneratedsSuper):
    """RestrictRecordsIndivid -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    ч
    а
    с
    т
    и
    (
    ч
    а
    с
    т
    е
    й
    )
    О
    Н
    )
    restrict_record -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restrict_record=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 restrict_record is None:
            self.restrict_record = []
        else:
            self.restrict_record = restrict_record
        self.restrict_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictRecordsIndivid)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictRecordsIndivid.subclass:
            return RestrictRecordsIndivid.subclass(*args_, **kwargs_)
        else:
            return RestrictRecordsIndivid(*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_restrict_record(self):
        return self.restrict_record
    def set_restrict_record(self, restrict_record):
        self.restrict_record = restrict_record
    def add_restrict_record(self, value):
        self.restrict_record.append(value)
    def insert_restrict_record_at(self, index, value):
        self.restrict_record.insert(index, value)
    def replace_restrict_record_at(self, index, value):
        self.restrict_record[index] = value
    def has__content(self):
        if (
            self.restrict_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordsIndivid', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictRecordsIndivid')
        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_ == 'RestrictRecordsIndivid':
            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_='RestrictRecordsIndivid')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictRecordsIndivid', 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_='RestrictRecordsIndivid'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordsIndivid', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restrict_record_ in self.restrict_record:
            namespaceprefix_ = self.restrict_record_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_record_nsprefix_) else ''
            restrict_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restrict_record':
            obj_ = restrict_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_record.append(obj_)
            obj_.original_tagname_ = 'restrict_record'
# end class RestrictRecordsIndivid


class RestrictRecordsIndividNoPart(GeneratedsSuper):
    """RestrictRecordsIndividNoPart -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restrict_record -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restrict_record=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 restrict_record is None:
            self.restrict_record = []
        else:
            self.restrict_record = restrict_record
        self.restrict_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictRecordsIndividNoPart)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictRecordsIndividNoPart.subclass:
            return RestrictRecordsIndividNoPart.subclass(*args_, **kwargs_)
        else:
            return RestrictRecordsIndividNoPart(*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_restrict_record(self):
        return self.restrict_record
    def set_restrict_record(self, restrict_record):
        self.restrict_record = restrict_record
    def add_restrict_record(self, value):
        self.restrict_record.append(value)
    def insert_restrict_record_at(self, index, value):
        self.restrict_record.insert(index, value)
    def replace_restrict_record_at(self, index, value):
        self.restrict_record[index] = value
    def has__content(self):
        if (
            self.restrict_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordsIndividNoPart', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictRecordsIndividNoPart')
        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_ == 'RestrictRecordsIndividNoPart':
            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_='RestrictRecordsIndividNoPart')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictRecordsIndividNoPart', 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_='RestrictRecordsIndividNoPart'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordsIndividNoPart', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restrict_record_ in self.restrict_record:
            namespaceprefix_ = self.restrict_record_nsprefix_ + ':' if (UseCapturedNS_ and self.restrict_record_nsprefix_) else ''
            restrict_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrict_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restrict_record':
            obj_ = restrict_recordType9.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrict_record.append(obj_)
            obj_.original_tagname_ = 'restrict_record'
# end class RestrictRecordsIndividNoPart


class RestrictionsEncumbrancesDataPart(GeneratedsSuper):
    """RestrictionsEncumbrancesDataPart -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restriction_encumbrance_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    О
    Н
    restriction_encumbrance_type -- В
    и
    д
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    period -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    additional_encumbrance_info -- Д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    в
    з
    а
    в
    и
    с
    и
    м
    о
    с
    т
    и
    о
    т
    в
    и
    д
    а
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    part_numbers -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    ч
    а
    с
    т
    е
    й
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restriction_encumbrance_number=None, restriction_encumbrance_type=None, period=None, additional_encumbrance_info=None, part_numbers=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.restriction_encumbrance_number = restriction_encumbrance_number
        self.restriction_encumbrance_number_nsprefix_ = None
        self.restriction_encumbrance_type = restriction_encumbrance_type
        self.restriction_encumbrance_type_nsprefix_ = None
        self.period = period
        self.period_nsprefix_ = None
        self.additional_encumbrance_info = additional_encumbrance_info
        self.additional_encumbrance_info_nsprefix_ = None
        self.part_numbers = part_numbers
        self.part_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictionsEncumbrancesDataPart)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictionsEncumbrancesDataPart.subclass:
            return RestrictionsEncumbrancesDataPart.subclass(*args_, **kwargs_)
        else:
            return RestrictionsEncumbrancesDataPart(*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_restriction_encumbrance_number(self):
        return self.restriction_encumbrance_number
    def set_restriction_encumbrance_number(self, restriction_encumbrance_number):
        self.restriction_encumbrance_number = restriction_encumbrance_number
    def get_restriction_encumbrance_type(self):
        return self.restriction_encumbrance_type
    def set_restriction_encumbrance_type(self, restriction_encumbrance_type):
        self.restriction_encumbrance_type = restriction_encumbrance_type
    def get_period(self):
        return self.period
    def set_period(self, period):
        self.period = period
    def get_additional_encumbrance_info(self):
        return self.additional_encumbrance_info
    def set_additional_encumbrance_info(self, additional_encumbrance_info):
        self.additional_encumbrance_info = additional_encumbrance_info
    def get_part_numbers(self):
        return self.part_numbers
    def set_part_numbers(self, part_numbers):
        self.part_numbers = part_numbers
    def has__content(self):
        if (
            self.restriction_encumbrance_number is not None or
            self.restriction_encumbrance_type is not None or
            self.period is not None or
            self.additional_encumbrance_info is not None or
            self.part_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictionsEncumbrancesDataPart', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictionsEncumbrancesDataPart')
        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_ == 'RestrictionsEncumbrancesDataPart':
            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_='RestrictionsEncumbrancesDataPart')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictionsEncumbrancesDataPart', 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_='RestrictionsEncumbrancesDataPart'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictionsEncumbrancesDataPart', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.restriction_encumbrance_number is not None:
            namespaceprefix_ = self.restriction_encumbrance_number_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%srestriction_encumbrance_number>%s</%srestriction_encumbrance_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.restriction_encumbrance_number), input_name='restriction_encumbrance_number')), namespaceprefix_ , eol_))
        if self.restriction_encumbrance_type is not None:
            namespaceprefix_ = self.restriction_encumbrance_type_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_type_nsprefix_) else ''
            self.restriction_encumbrance_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restriction_encumbrance_type', pretty_print=pretty_print)
        if self.period is not None:
            namespaceprefix_ = self.period_nsprefix_ + ':' if (UseCapturedNS_ and self.period_nsprefix_) else ''
            self.period.export(outfile, level, namespaceprefix_, namespacedef_='', name_='period', pretty_print=pretty_print)
        if self.additional_encumbrance_info is not None:
            namespaceprefix_ = self.additional_encumbrance_info_nsprefix_ + ':' if (UseCapturedNS_ and self.additional_encumbrance_info_nsprefix_) else ''
            self.additional_encumbrance_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='additional_encumbrance_info', pretty_print=pretty_print)
        if self.part_numbers is not None:
            namespaceprefix_ = self.part_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.part_numbers_nsprefix_) else ''
            self.part_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restriction_encumbrance_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'restriction_encumbrance_number')
            value_ = self.gds_validate_string(value_, node, 'restriction_encumbrance_number')
            self.restriction_encumbrance_number = value_
            self.restriction_encumbrance_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'restriction_encumbrance_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restriction_encumbrance_type = obj_
            obj_.original_tagname_ = 'restriction_encumbrance_type'
        elif nodeName_ == 'period':
            obj_ = periodType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.period = obj_
            obj_.original_tagname_ = 'period'
        elif nodeName_ == 'additional_encumbrance_info':
            obj_ = additional_encumbrance_infoType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.additional_encumbrance_info = obj_
            obj_.original_tagname_ = 'additional_encumbrance_info'
        elif nodeName_ == 'part_numbers':
            obj_ = PartNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.part_numbers = obj_
            obj_.original_tagname_ = 'part_numbers'
# end class RestrictionsEncumbrancesDataPart


class ContoursZUOut(GeneratedsSuper):
    """ContoursZUOut -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    о
    в
    г
    р
    а
    н
    и
    ц
    ы
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    contours -- К
    о
    н
    т
    у
    р
    ы
    г
    р
    а
    н
    и
    ц
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, contours=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.contours = contours
        self.contours_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContoursZUOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContoursZUOut.subclass:
            return ContoursZUOut.subclass(*args_, **kwargs_)
        else:
            return ContoursZUOut(*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_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def has__content(self):
        if (
            self.contours is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursZUOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContoursZUOut')
        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_ == 'ContoursZUOut':
            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_='ContoursZUOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContoursZUOut', 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_='ContoursZUOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursZUOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'contours':
            obj_ = contoursType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
# end class ContoursZUOut


class ContourZUOut(GeneratedsSuper):
    """ContourZUOut -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    г
    р
    а
    н
    и
    ц
    ы
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    number_pp -- Н
    о
    м
    е
    р
    к
    о
    н
    т
    у
    р
    а
    cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    у
    ч
    а
    с
    т
    к
    а
    ,
    в
    х
    о
    д
    я
    щ
    е
    г
    о
    в
    с
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    entity_spatial -- О
    п
    и
    с
    а
    н
    и
    е
    э
    л
    е
    м
    е
    н
    т
    о
    в
    к
    о
    н
    т
    у
    р
    а
    (
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_pp=None, cad_number=None, entity_spatial=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.number_pp = number_pp
        self.number_pp_nsprefix_ = None
        self.cad_number = cad_number
        self.cad_number_nsprefix_ = None
        self.entity_spatial = entity_spatial
        self.entity_spatial_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContourZUOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContourZUOut.subclass:
            return ContourZUOut.subclass(*args_, **kwargs_)
        else:
            return ContourZUOut(*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_pp(self):
        return self.number_pp
    def set_number_pp(self, number_pp):
        self.number_pp = number_pp
    def get_cad_number(self):
        return self.cad_number
    def set_cad_number(self, cad_number):
        self.cad_number = cad_number
    def get_entity_spatial(self):
        return self.entity_spatial
    def set_entity_spatial(self, entity_spatial):
        self.entity_spatial = entity_spatial
    def has__content(self):
        if (
            self.number_pp is not None or
            self.cad_number is not None or
            self.entity_spatial is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContourZUOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContourZUOut')
        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_ == 'ContourZUOut':
            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_='ContourZUOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContourZUOut', 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_='ContourZUOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContourZUOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_pp is not None:
            namespaceprefix_ = self.number_pp_nsprefix_ + ':' if (UseCapturedNS_ and self.number_pp_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_pp>%s</%snumber_pp>%s' % (namespaceprefix_ , self.gds_format_integer(self.number_pp, input_name='number_pp'), namespaceprefix_ , eol_))
        if self.cad_number is not None:
            namespaceprefix_ = self.cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scad_number>%s</%scad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cad_number), input_name='cad_number')), namespaceprefix_ , eol_))
        if self.entity_spatial is not None:
            namespaceprefix_ = self.entity_spatial_nsprefix_ + ':' if (UseCapturedNS_ and self.entity_spatial_nsprefix_) else ''
            self.entity_spatial.export(outfile, level, namespaceprefix_, namespacedef_='', name_='entity_spatial', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_pp' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'number_pp')
            ival_ = self.gds_validate_integer(ival_, node, 'number_pp')
            self.number_pp = ival_
            self.number_pp_nsprefix_ = child_.prefix
        elif nodeName_ == 'cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cad_number')
            value_ = self.gds_validate_string(value_, node, 'cad_number')
            self.cad_number = value_
            self.cad_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'entity_spatial':
            obj_ = EntitySpatialZUOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.entity_spatial = obj_
            obj_.original_tagname_ = 'entity_spatial'
# end class ContourZUOut


class ContoursLocationZUOut(GeneratedsSuper):
    """ContoursLocationZUOut -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    (
    и
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    З
    У
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    contours_location -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    г
    р
    а
    н
    и
    ц
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, contours_location=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.object = object
        self.object_nsprefix_ = None
        self.contours_location = contours_location
        self.contours_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContoursLocationZUOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContoursLocationZUOut.subclass:
            return ContoursLocationZUOut.subclass(*args_, **kwargs_)
        else:
            return ContoursLocationZUOut(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_contours_location(self):
        return self.contours_location
    def set_contours_location(self, contours_location):
        self.contours_location = contours_location
    def has__content(self):
        if (
            self.object is not None or
            self.contours_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursLocationZUOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContoursLocationZUOut')
        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_ == 'ContoursLocationZUOut':
            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_='ContoursLocationZUOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContoursLocationZUOut', 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_='ContoursLocationZUOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursLocationZUOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.contours_location is not None:
            namespaceprefix_ = self.contours_location_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_location_nsprefix_) else ''
            self.contours_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectCadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'contours_location':
            obj_ = ContoursZUOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours_location = obj_
            obj_.original_tagname_ = 'contours_location'
# end class ContoursLocationZUOut


class EntitySpatialZUOut(GeneratedsSuper):
    """EntitySpatialZUOut -- О
    п
    и
    с
    а
    н
    и
    е
    э
    л
    е
    м
    е
    н
    т
    о
    в
    к
    о
    н
    т
    у
    р
    а
    (
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    )
    sk_id -- С
    и
    с
    т
    е
    м
    а
    к
    о
    о
    р
    д
    и
    н
    а
    т
    spatials_elements -- Э
    л
    е
    м
    е
    н
    т
    ы
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, sk_id=None, spatials_elements=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.sk_id = sk_id
        self.sk_id_nsprefix_ = None
        self.spatials_elements = spatials_elements
        self.spatials_elements_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, EntitySpatialZUOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if EntitySpatialZUOut.subclass:
            return EntitySpatialZUOut.subclass(*args_, **kwargs_)
        else:
            return EntitySpatialZUOut(*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_sk_id(self):
        return self.sk_id
    def set_sk_id(self, sk_id):
        self.sk_id = sk_id
    def get_spatials_elements(self):
        return self.spatials_elements
    def set_spatials_elements(self, spatials_elements):
        self.spatials_elements = spatials_elements
    def has__content(self):
        if (
            self.sk_id is not None or
            self.spatials_elements is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntitySpatialZUOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('EntitySpatialZUOut')
        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_ == 'EntitySpatialZUOut':
            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_='EntitySpatialZUOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='EntitySpatialZUOut', 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_='EntitySpatialZUOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntitySpatialZUOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.sk_id is not None:
            namespaceprefix_ = self.sk_id_nsprefix_ + ':' if (UseCapturedNS_ and self.sk_id_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssk_id>%s</%ssk_id>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.sk_id), input_name='sk_id')), namespaceprefix_ , eol_))
        if self.spatials_elements is not None:
            namespaceprefix_ = self.spatials_elements_nsprefix_ + ':' if (UseCapturedNS_ and self.spatials_elements_nsprefix_) else ''
            self.spatials_elements.export(outfile, level, namespaceprefix_, namespacedef_='', name_='spatials_elements', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'sk_id':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'sk_id')
            value_ = self.gds_validate_string(value_, node, 'sk_id')
            self.sk_id = value_
            self.sk_id_nsprefix_ = child_.prefix
        elif nodeName_ == 'spatials_elements':
            obj_ = SpatialsElementsZUOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.spatials_elements = obj_
            obj_.original_tagname_ = 'spatials_elements'
# end class EntitySpatialZUOut


class OrdinatesZUOut(GeneratedsSuper):
    """OrdinatesZUOut -- С
    п
    и
    с
    о
    к
    к
    о
    о
    р
    д
    и
    н
    а
    т
    ordinate -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ordinate=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 ordinate is None:
            self.ordinate = []
        else:
            self.ordinate = ordinate
        self.ordinate_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OrdinatesZUOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OrdinatesZUOut.subclass:
            return OrdinatesZUOut.subclass(*args_, **kwargs_)
        else:
            return OrdinatesZUOut(*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_ordinate(self):
        return self.ordinate
    def set_ordinate(self, ordinate):
        self.ordinate = ordinate
    def add_ordinate(self, value):
        self.ordinate.append(value)
    def insert_ordinate_at(self, index, value):
        self.ordinate.insert(index, value)
    def replace_ordinate_at(self, index, value):
        self.ordinate[index] = value
    def has__content(self):
        if (
            self.ordinate
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinatesZUOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OrdinatesZUOut')
        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_ == 'OrdinatesZUOut':
            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_='OrdinatesZUOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OrdinatesZUOut', 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_='OrdinatesZUOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinatesZUOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ordinate_ in self.ordinate:
            namespaceprefix_ = self.ordinate_nsprefix_ + ':' if (UseCapturedNS_ and self.ordinate_nsprefix_) else ''
            ordinate_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ordinate', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ordinate':
            obj_ = OrdinateZUOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ordinate.append(obj_)
            obj_.original_tagname_ = 'ordinate'
# end class OrdinatesZUOut


class SpatialsElementsZUOut(GeneratedsSuper):
    """SpatialsElementsZUOut -- Э
    л
    е
    м
    е
    н
    т
    ы
    к
    о
    н
    т
    у
    р
    а
    З
    У
    spatial_element -- Э
    л
    е
    м
    е
    н
    т
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, spatial_element=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 spatial_element is None:
            self.spatial_element = []
        else:
            self.spatial_element = spatial_element
        self.spatial_element_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpatialsElementsZUOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpatialsElementsZUOut.subclass:
            return SpatialsElementsZUOut.subclass(*args_, **kwargs_)
        else:
            return SpatialsElementsZUOut(*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_spatial_element(self):
        return self.spatial_element
    def set_spatial_element(self, spatial_element):
        self.spatial_element = spatial_element
    def add_spatial_element(self, value):
        self.spatial_element.append(value)
    def insert_spatial_element_at(self, index, value):
        self.spatial_element.insert(index, value)
    def replace_spatial_element_at(self, index, value):
        self.spatial_element[index] = value
    def has__content(self):
        if (
            self.spatial_element
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialsElementsZUOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpatialsElementsZUOut')
        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_ == 'SpatialsElementsZUOut':
            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_='SpatialsElementsZUOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpatialsElementsZUOut', 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_='SpatialsElementsZUOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialsElementsZUOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for spatial_element_ in self.spatial_element:
            namespaceprefix_ = self.spatial_element_nsprefix_ + ':' if (UseCapturedNS_ and self.spatial_element_nsprefix_) else ''
            spatial_element_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='spatial_element', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'spatial_element':
            obj_ = SpatialsElementZUOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.spatial_element.append(obj_)
            obj_.original_tagname_ = 'spatial_element'
# end class SpatialsElementsZUOut


class SpatialsElementZUOut(GeneratedsSuper):
    """SpatialsElementZUOut -- Э
    л
    е
    м
    е
    н
    т
    к
    о
    н
    т
    у
    р
    а
    ordinates -- С
    п
    и
    с
    о
    к
    к
    о
    о
    р
    д
    и
    н
    а
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ordinates=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.ordinates = ordinates
        self.ordinates_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpatialsElementZUOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpatialsElementZUOut.subclass:
            return SpatialsElementZUOut.subclass(*args_, **kwargs_)
        else:
            return SpatialsElementZUOut(*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_ordinates(self):
        return self.ordinates
    def set_ordinates(self, ordinates):
        self.ordinates = ordinates
    def has__content(self):
        if (
            self.ordinates is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialsElementZUOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpatialsElementZUOut')
        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_ == 'SpatialsElementZUOut':
            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_='SpatialsElementZUOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpatialsElementZUOut', 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_='SpatialsElementZUOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialsElementZUOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ordinates is not None:
            namespaceprefix_ = self.ordinates_nsprefix_ + ':' if (UseCapturedNS_ and self.ordinates_nsprefix_) else ''
            self.ordinates.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ordinates', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ordinates':
            obj_ = OrdinatesZUOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ordinates = obj_
            obj_.original_tagname_ = 'ordinates'
# end class SpatialsElementZUOut


class OrdinateZUOut(GeneratedsSuper):
    """OrdinateZUOut -- К
    о
    о
    р
    д
    и
    н
    а
    т
    ы
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    x -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    X
    y -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    Y
    z -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    Z
    ord_nmb -- Н
    о
    м
    е
    р
    т
    о
    ч
    к
    и
    (
    п
    о
    р
    я
    д
    о
    к
    о
    б
    х
    о
    д
    а
    )
    num_geopoint -- Н
    о
    м
    е
    р
    м
    е
    ж
    е
    в
    о
    й
    т
    о
    ч
    к
    и
    delta_geopoint -- П
    о
    г
    р
    е
    ш
    н
    о
    с
    т
    ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, x=None, y=None, z=None, ord_nmb=None, num_geopoint=None, delta_geopoint=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.x = x
        self.x_nsprefix_ = None
        self.y = y
        self.y_nsprefix_ = None
        self.z = z
        self.z_nsprefix_ = None
        self.ord_nmb = ord_nmb
        self.ord_nmb_nsprefix_ = None
        self.num_geopoint = num_geopoint
        self.num_geopoint_nsprefix_ = None
        self.delta_geopoint = delta_geopoint
        self.delta_geopoint_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OrdinateZUOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OrdinateZUOut.subclass:
            return OrdinateZUOut.subclass(*args_, **kwargs_)
        else:
            return OrdinateZUOut(*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_x(self):
        return self.x
    def set_x(self, x):
        self.x = x
    def get_y(self):
        return self.y
    def set_y(self, y):
        self.y = y
    def get_z(self):
        return self.z
    def set_z(self, z):
        self.z = z
    def get_ord_nmb(self):
        return self.ord_nmb
    def set_ord_nmb(self, ord_nmb):
        self.ord_nmb = ord_nmb
    def get_num_geopoint(self):
        return self.num_geopoint
    def set_num_geopoint(self, num_geopoint):
        self.num_geopoint = num_geopoint
    def get_delta_geopoint(self):
        return self.delta_geopoint
    def set_delta_geopoint(self, delta_geopoint):
        self.delta_geopoint = delta_geopoint
    def has__content(self):
        if (
            self.x is not None or
            self.y is not None or
            self.z is not None or
            self.ord_nmb is not None or
            self.num_geopoint is not None or
            self.delta_geopoint is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinateZUOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OrdinateZUOut')
        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_ == 'OrdinateZUOut':
            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_='OrdinateZUOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OrdinateZUOut', 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_='OrdinateZUOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinateZUOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.x is not None:
            namespaceprefix_ = self.x_nsprefix_ + ':' if (UseCapturedNS_ and self.x_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sx>%s</%sx>%s' % (namespaceprefix_ , self.gds_format_decimal(self.x, input_name='x'), namespaceprefix_ , eol_))
        if self.y is not None:
            namespaceprefix_ = self.y_nsprefix_ + ':' if (UseCapturedNS_ and self.y_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sy>%s</%sy>%s' % (namespaceprefix_ , self.gds_format_decimal(self.y, input_name='y'), namespaceprefix_ , eol_))
        if self.z is not None:
            namespaceprefix_ = self.z_nsprefix_ + ':' if (UseCapturedNS_ and self.z_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sz>%s</%sz>%s' % (namespaceprefix_ , self.gds_format_decimal(self.z, input_name='z'), namespaceprefix_ , eol_))
        if self.ord_nmb is not None:
            namespaceprefix_ = self.ord_nmb_nsprefix_ + ':' if (UseCapturedNS_ and self.ord_nmb_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sord_nmb>%s</%sord_nmb>%s' % (namespaceprefix_ , self.gds_format_integer(self.ord_nmb, input_name='ord_nmb'), namespaceprefix_ , eol_))
        if self.num_geopoint is not None:
            namespaceprefix_ = self.num_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.num_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snum_geopoint>%s</%snum_geopoint>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.num_geopoint), input_name='num_geopoint')), namespaceprefix_ , eol_))
        if self.delta_geopoint is not None:
            namespaceprefix_ = self.delta_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdelta_geopoint>%s</%sdelta_geopoint>%s' % (namespaceprefix_ , self.gds_format_decimal(self.delta_geopoint, input_name='delta_geopoint'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'x' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'x')
            fval_ = self.gds_validate_decimal(fval_, node, 'x')
            self.x = fval_
            self.x_nsprefix_ = child_.prefix
        elif nodeName_ == 'y' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'y')
            fval_ = self.gds_validate_decimal(fval_, node, 'y')
            self.y = fval_
            self.y_nsprefix_ = child_.prefix
        elif nodeName_ == 'z' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'z')
            fval_ = self.gds_validate_decimal(fval_, node, 'z')
            self.z = fval_
            self.z_nsprefix_ = child_.prefix
        elif nodeName_ == 'ord_nmb' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'ord_nmb')
            ival_ = self.gds_validate_integer(ival_, node, 'ord_nmb')
            self.ord_nmb = ival_
            self.ord_nmb_nsprefix_ = child_.prefix
        elif nodeName_ == 'num_geopoint':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'num_geopoint')
            value_ = self.gds_validate_string(value_, node, 'num_geopoint')
            self.num_geopoint = value_
            self.num_geopoint_nsprefix_ = child_.prefix
        elif nodeName_ == 'delta_geopoint' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'delta_geopoint')
            fval_ = self.gds_validate_decimal(fval_, node, 'delta_geopoint')
            self.delta_geopoint = fval_
            self.delta_geopoint_nsprefix_ = child_.prefix
# end class OrdinateZUOut


class ContoursAreaZU(GeneratedsSuper):
    """ContoursAreaZU -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    о
    в
    г
    р
    а
    н
    и
    ц
    ы
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    и
    п
    л
    о
    щ
    а
    д
    ь
    )
    contour -- К
    о
    н
    т
    у
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, contour=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 contour is None:
            self.contour = []
        else:
            self.contour = contour
        self.contour_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContoursAreaZU)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContoursAreaZU.subclass:
            return ContoursAreaZU.subclass(*args_, **kwargs_)
        else:
            return ContoursAreaZU(*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_contour(self):
        return self.contour
    def set_contour(self, contour):
        self.contour = contour
    def add_contour(self, value):
        self.contour.append(value)
    def insert_contour_at(self, index, value):
        self.contour.insert(index, value)
    def replace_contour_at(self, index, value):
        self.contour[index] = value
    def has__content(self):
        if (
            self.contour
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursAreaZU', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContoursAreaZU')
        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_ == 'ContoursAreaZU':
            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_='ContoursAreaZU')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContoursAreaZU', 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_='ContoursAreaZU'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursAreaZU', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for contour_ in self.contour:
            namespaceprefix_ = self.contour_nsprefix_ + ':' if (UseCapturedNS_ and self.contour_nsprefix_) else ''
            contour_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contour', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'contour':
            obj_ = ContourAreaZU.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contour.append(obj_)
            obj_.original_tagname_ = 'contour'
# end class ContoursAreaZU


class ContourAreaZU(GeneratedsSuper):
    """ContourAreaZU -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    г
    р
    а
    н
    и
    ц
    ы
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    и
    п
    л
    о
    щ
    а
    д
    ь
    )
    number_pp -- Н
    о
    м
    е
    р
    к
    о
    н
    т
    у
    р
    а
    cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    у
    ч
    а
    с
    т
    к
    а
    ,
    в
    х
    о
    д
    я
    щ
    е
    г
    о
    в
    с
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    area -- П
    л
    о
    щ
    а
    д
    ь
    entity_spatial -- О
    п
    и
    с
    а
    н
    и
    е
    э
    л
    е
    м
    е
    н
    т
    о
    в
    к
    о
    н
    т
    у
    р
    а
    (
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_pp=None, cad_number=None, area=None, entity_spatial=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.number_pp = number_pp
        self.number_pp_nsprefix_ = None
        self.cad_number = cad_number
        self.cad_number_nsprefix_ = None
        self.area = area
        self.area_nsprefix_ = None
        self.entity_spatial = entity_spatial
        self.entity_spatial_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContourAreaZU)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContourAreaZU.subclass:
            return ContourAreaZU.subclass(*args_, **kwargs_)
        else:
            return ContourAreaZU(*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_pp(self):
        return self.number_pp
    def set_number_pp(self, number_pp):
        self.number_pp = number_pp
    def get_cad_number(self):
        return self.cad_number
    def set_cad_number(self, cad_number):
        self.cad_number = cad_number
    def get_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_entity_spatial(self):
        return self.entity_spatial
    def set_entity_spatial(self, entity_spatial):
        self.entity_spatial = entity_spatial
    def has__content(self):
        if (
            self.number_pp is not None or
            self.cad_number is not None or
            self.area is not None or
            self.entity_spatial is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContourAreaZU', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContourAreaZU')
        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_ == 'ContourAreaZU':
            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_='ContourAreaZU')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContourAreaZU', 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_='ContourAreaZU'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContourAreaZU', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_pp is not None:
            namespaceprefix_ = self.number_pp_nsprefix_ + ':' if (UseCapturedNS_ and self.number_pp_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_pp>%s</%snumber_pp>%s' % (namespaceprefix_ , self.gds_format_integer(self.number_pp, input_name='number_pp'), namespaceprefix_ , eol_))
        if self.cad_number is not None:
            namespaceprefix_ = self.cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scad_number>%s</%scad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cad_number), input_name='cad_number')), namespaceprefix_ , eol_))
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            self.area.export(outfile, level, namespaceprefix_, namespacedef_='', name_='area', pretty_print=pretty_print)
        if self.entity_spatial is not None:
            namespaceprefix_ = self.entity_spatial_nsprefix_ + ':' if (UseCapturedNS_ and self.entity_spatial_nsprefix_) else ''
            self.entity_spatial.export(outfile, level, namespaceprefix_, namespacedef_='', name_='entity_spatial', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_pp' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'number_pp')
            ival_ = self.gds_validate_integer(ival_, node, 'number_pp')
            self.number_pp = ival_
            self.number_pp_nsprefix_ = child_.prefix
        elif nodeName_ == 'cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cad_number')
            value_ = self.gds_validate_string(value_, node, 'cad_number')
            self.cad_number = value_
            self.cad_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'area':
            obj_ = AreaValue.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.area = obj_
            obj_.original_tagname_ = 'area'
        elif nodeName_ == 'entity_spatial':
            obj_ = EntitySpatialZUZacrep.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.entity_spatial = obj_
            obj_.original_tagname_ = 'entity_spatial'
# end class ContourAreaZU


class ContoursLocationZUZacrep(GeneratedsSuper):
    """ContoursLocationZUZacrep -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    contours -- К
    о
    н
    т
    у
    р
    ы
    г
    р
    а
    н
    и
    ц
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, contours=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.contours = contours
        self.contours_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContoursLocationZUZacrep)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContoursLocationZUZacrep.subclass:
            return ContoursLocationZUZacrep.subclass(*args_, **kwargs_)
        else:
            return ContoursLocationZUZacrep(*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_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def has__content(self):
        if (
            self.contours is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursLocationZUZacrep', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContoursLocationZUZacrep')
        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_ == 'ContoursLocationZUZacrep':
            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_='ContoursLocationZUZacrep')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContoursLocationZUZacrep', 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_='ContoursLocationZUZacrep'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursLocationZUZacrep', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'contours':
            obj_ = ContoursZUZacrep.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
# end class ContoursLocationZUZacrep


class ContoursLocationBorders(GeneratedsSuper):
    """ContoursLocationBorders -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    ч
    а
    с
    т
    и
    г
    р
    а
    н
    и
    ц
    (
    о
    т
    т
    о
    ч
    к
    и
    д
    о
    т
    о
    ч
    к
    и
    )
    и
    н
    а
    л
    и
    ч
    и
    е
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    с
    п
    о
    р
    а
    )
    contours -- К
    о
    н
    т
    у
    р
    ы
    г
    р
    а
    н
    и
    ц
    ы
    borders -- О
    п
    и
    с
    а
    н
    и
    е
    г
    р
    а
    н
    и
    ц
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    о
    т
    т
    о
    ч
    к
    и
    д
    о
    т
    о
    ч
    к
    и
    )
    и
    н
    а
    л
    и
    ч
    и
    е
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    с
    п
    о
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, contours=None, borders=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.contours = contours
        self.contours_nsprefix_ = None
        self.borders = borders
        self.borders_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContoursLocationBorders)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContoursLocationBorders.subclass:
            return ContoursLocationBorders.subclass(*args_, **kwargs_)
        else:
            return ContoursLocationBorders(*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_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def get_borders(self):
        return self.borders
    def set_borders(self, borders):
        self.borders = borders
    def has__content(self):
        if (
            self.contours is not None or
            self.borders is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursLocationBorders', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContoursLocationBorders')
        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_ == 'ContoursLocationBorders':
            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_='ContoursLocationBorders')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContoursLocationBorders', 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_='ContoursLocationBorders'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursLocationBorders', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', pretty_print=pretty_print)
        if self.borders is not None:
            namespaceprefix_ = self.borders_nsprefix_ + ':' if (UseCapturedNS_ and self.borders_nsprefix_) else ''
            self.borders.export(outfile, level, namespaceprefix_, namespacedef_='', name_='borders', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'contours':
            obj_ = ContoursAreaZU.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
        elif nodeName_ == 'borders':
            obj_ = Borders.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.borders = obj_
            obj_.original_tagname_ = 'borders'
# end class ContoursLocationBorders


class ContoursZUZacrep(GeneratedsSuper):
    """ContoursZUZacrep -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    г
    р
    а
    н
    и
    ц
    ы
    (
    н
    о
    м
    е
    р
    к
    о
    н
    т
    у
    р
    а
    и
    с
    и
    с
    т
    е
    м
    а
    к
    о
    о
    р
    д
    и
    н
    а
    т
    contour -- К
    о
    н
    т
    у
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, contour=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 contour is None:
            self.contour = []
        else:
            self.contour = contour
        self.contour_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContoursZUZacrep)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContoursZUZacrep.subclass:
            return ContoursZUZacrep.subclass(*args_, **kwargs_)
        else:
            return ContoursZUZacrep(*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_contour(self):
        return self.contour
    def set_contour(self, contour):
        self.contour = contour
    def add_contour(self, value):
        self.contour.append(value)
    def insert_contour_at(self, index, value):
        self.contour.insert(index, value)
    def replace_contour_at(self, index, value):
        self.contour[index] = value
    def has__content(self):
        if (
            self.contour
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursZUZacrep', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContoursZUZacrep')
        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_ == 'ContoursZUZacrep':
            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_='ContoursZUZacrep')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContoursZUZacrep', 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_='ContoursZUZacrep'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursZUZacrep', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for contour_ in self.contour:
            namespaceprefix_ = self.contour_nsprefix_ + ':' if (UseCapturedNS_ and self.contour_nsprefix_) else ''
            contour_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contour', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'contour':
            obj_ = ContourZUZacrep.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contour.append(obj_)
            obj_.original_tagname_ = 'contour'
# end class ContoursZUZacrep


class ContourZUZacrep(GeneratedsSuper):
    """ContourZUZacrep -- К
    о
    н
    т
    у
    р
    number_pp -- Н
    о
    м
    е
    р
    к
    о
    н
    т
    у
    р
    а
    entity_spatial -- О
    п
    и
    с
    а
    н
    и
    е
    э
    л
    е
    м
    е
    н
    т
    о
    в
    к
    о
    н
    т
    у
    р
    а
    (
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_pp=None, entity_spatial=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.number_pp = number_pp
        self.number_pp_nsprefix_ = None
        self.entity_spatial = entity_spatial
        self.entity_spatial_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContourZUZacrep)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContourZUZacrep.subclass:
            return ContourZUZacrep.subclass(*args_, **kwargs_)
        else:
            return ContourZUZacrep(*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_pp(self):
        return self.number_pp
    def set_number_pp(self, number_pp):
        self.number_pp = number_pp
    def get_entity_spatial(self):
        return self.entity_spatial
    def set_entity_spatial(self, entity_spatial):
        self.entity_spatial = entity_spatial
    def has__content(self):
        if (
            self.number_pp is not None or
            self.entity_spatial is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContourZUZacrep', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContourZUZacrep')
        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_ == 'ContourZUZacrep':
            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_='ContourZUZacrep')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContourZUZacrep', 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_='ContourZUZacrep'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContourZUZacrep', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_pp is not None:
            namespaceprefix_ = self.number_pp_nsprefix_ + ':' if (UseCapturedNS_ and self.number_pp_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_pp>%s</%snumber_pp>%s' % (namespaceprefix_ , self.gds_format_integer(self.number_pp, input_name='number_pp'), namespaceprefix_ , eol_))
        if self.entity_spatial is not None:
            namespaceprefix_ = self.entity_spatial_nsprefix_ + ':' if (UseCapturedNS_ and self.entity_spatial_nsprefix_) else ''
            self.entity_spatial.export(outfile, level, namespaceprefix_, namespacedef_='', name_='entity_spatial', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_pp' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'number_pp')
            ival_ = self.gds_validate_integer(ival_, node, 'number_pp')
            self.number_pp = ival_
            self.number_pp_nsprefix_ = child_.prefix
        elif nodeName_ == 'entity_spatial':
            obj_ = EntitySpatialZUZacrep.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.entity_spatial = obj_
            obj_.original_tagname_ = 'entity_spatial'
# end class ContourZUZacrep


class EntitySpatialZUZacrep(GeneratedsSuper):
    """EntitySpatialZUZacrep -- О
    п
    и
    с
    а
    н
    и
    е
    э
    л
    е
    м
    е
    н
    т
    о
    в
    к
    о
    н
    т
    у
    р
    а
    (
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    ) (
    в
    т
    о
    м
    ч
    и
    с
    л
    е
    з
    а
    к
    р
    е
    п
    л
    е
    н
    и
    е
    т
    о
    ч
    к
    и
    )
    sk_id -- С
    и
    с
    т
    е
    м
    а
    к
    о
    о
    р
    д
    и
    н
    а
    т
    spatials_elements -- Э
    л
    е
    м
    е
    н
    т
    ы
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, sk_id=None, spatials_elements=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.sk_id = sk_id
        self.sk_id_nsprefix_ = None
        self.spatials_elements = spatials_elements
        self.spatials_elements_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, EntitySpatialZUZacrep)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if EntitySpatialZUZacrep.subclass:
            return EntitySpatialZUZacrep.subclass(*args_, **kwargs_)
        else:
            return EntitySpatialZUZacrep(*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_sk_id(self):
        return self.sk_id
    def set_sk_id(self, sk_id):
        self.sk_id = sk_id
    def get_spatials_elements(self):
        return self.spatials_elements
    def set_spatials_elements(self, spatials_elements):
        self.spatials_elements = spatials_elements
    def has__content(self):
        if (
            self.sk_id is not None or
            self.spatials_elements is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntitySpatialZUZacrep', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('EntitySpatialZUZacrep')
        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_ == 'EntitySpatialZUZacrep':
            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_='EntitySpatialZUZacrep')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='EntitySpatialZUZacrep', 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_='EntitySpatialZUZacrep'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntitySpatialZUZacrep', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.sk_id is not None:
            namespaceprefix_ = self.sk_id_nsprefix_ + ':' if (UseCapturedNS_ and self.sk_id_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssk_id>%s</%ssk_id>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.sk_id), input_name='sk_id')), namespaceprefix_ , eol_))
        if self.spatials_elements is not None:
            namespaceprefix_ = self.spatials_elements_nsprefix_ + ':' if (UseCapturedNS_ and self.spatials_elements_nsprefix_) else ''
            self.spatials_elements.export(outfile, level, namespaceprefix_, namespacedef_='', name_='spatials_elements', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'sk_id':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'sk_id')
            value_ = self.gds_validate_string(value_, node, 'sk_id')
            self.sk_id = value_
            self.sk_id_nsprefix_ = child_.prefix
        elif nodeName_ == 'spatials_elements':
            obj_ = SpatialsElementsZacrep.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.spatials_elements = obj_
            obj_.original_tagname_ = 'spatials_elements'
# end class EntitySpatialZUZacrep


class SpatialsElementsZacrep(GeneratedsSuper):
    """SpatialsElementsZacrep -- Э
    л
    е
    м
    е
    н
    т
    ы
    к
    о
    н
    т
    у
    р
    а
    З
    У
    и
    с
    п
    о
    с
    о
    б
    з
    а
    к
    р
    е
    п
    л
    е
    н
    и
    я
    т
    о
    ч
    к
    и
    spatial_element -- Э
    л
    е
    м
    е
    н
    т
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, spatial_element=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 spatial_element is None:
            self.spatial_element = []
        else:
            self.spatial_element = spatial_element
        self.spatial_element_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpatialsElementsZacrep)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpatialsElementsZacrep.subclass:
            return SpatialsElementsZacrep.subclass(*args_, **kwargs_)
        else:
            return SpatialsElementsZacrep(*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_spatial_element(self):
        return self.spatial_element
    def set_spatial_element(self, spatial_element):
        self.spatial_element = spatial_element
    def add_spatial_element(self, value):
        self.spatial_element.append(value)
    def insert_spatial_element_at(self, index, value):
        self.spatial_element.insert(index, value)
    def replace_spatial_element_at(self, index, value):
        self.spatial_element[index] = value
    def has__content(self):
        if (
            self.spatial_element
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialsElementsZacrep', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpatialsElementsZacrep')
        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_ == 'SpatialsElementsZacrep':
            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_='SpatialsElementsZacrep')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpatialsElementsZacrep', 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_='SpatialsElementsZacrep'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialsElementsZacrep', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for spatial_element_ in self.spatial_element:
            namespaceprefix_ = self.spatial_element_nsprefix_ + ':' if (UseCapturedNS_ and self.spatial_element_nsprefix_) else ''
            spatial_element_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='spatial_element', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'spatial_element':
            obj_ = SpatialElementZacrep.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.spatial_element.append(obj_)
            obj_.original_tagname_ = 'spatial_element'
# end class SpatialsElementsZacrep


class SpatialElementZacrep(GeneratedsSuper):
    """SpatialElementZacrep -- Э
    л
    е
    м
    е
    н
    т
    к
    о
    н
    т
    у
    р
    а
    ordinates -- С
    п
    и
    с
    о
    к
    к
    о
    о
    р
    д
    и
    н
    а
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ordinates=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.ordinates = ordinates
        self.ordinates_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpatialElementZacrep)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpatialElementZacrep.subclass:
            return SpatialElementZacrep.subclass(*args_, **kwargs_)
        else:
            return SpatialElementZacrep(*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_ordinates(self):
        return self.ordinates
    def set_ordinates(self, ordinates):
        self.ordinates = ordinates
    def has__content(self):
        if (
            self.ordinates is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialElementZacrep', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpatialElementZacrep')
        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_ == 'SpatialElementZacrep':
            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_='SpatialElementZacrep')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpatialElementZacrep', 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_='SpatialElementZacrep'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialElementZacrep', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ordinates is not None:
            namespaceprefix_ = self.ordinates_nsprefix_ + ':' if (UseCapturedNS_ and self.ordinates_nsprefix_) else ''
            self.ordinates.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ordinates', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ordinates':
            obj_ = OrdinatesZacrep.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ordinates = obj_
            obj_.original_tagname_ = 'ordinates'
# end class SpatialElementZacrep


class OrdinatesZacrep(GeneratedsSuper):
    """OrdinatesZacrep -- С
    п
    и
    с
    о
    к
    к
    о
    о
    р
    д
    и
    н
    а
    т
    ordinate -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ordinate=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 ordinate is None:
            self.ordinate = []
        else:
            self.ordinate = ordinate
        self.ordinate_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OrdinatesZacrep)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OrdinatesZacrep.subclass:
            return OrdinatesZacrep.subclass(*args_, **kwargs_)
        else:
            return OrdinatesZacrep(*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_ordinate(self):
        return self.ordinate
    def set_ordinate(self, ordinate):
        self.ordinate = ordinate
    def add_ordinate(self, value):
        self.ordinate.append(value)
    def insert_ordinate_at(self, index, value):
        self.ordinate.insert(index, value)
    def replace_ordinate_at(self, index, value):
        self.ordinate[index] = value
    def has__content(self):
        if (
            self.ordinate
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinatesZacrep', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OrdinatesZacrep')
        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_ == 'OrdinatesZacrep':
            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_='OrdinatesZacrep')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OrdinatesZacrep', 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_='OrdinatesZacrep'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinatesZacrep', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ordinate_ in self.ordinate:
            namespaceprefix_ = self.ordinate_nsprefix_ + ':' if (UseCapturedNS_ and self.ordinate_nsprefix_) else ''
            ordinate_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ordinate', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ordinate':
            obj_ = OrdinateZacrep.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ordinate.append(obj_)
            obj_.original_tagname_ = 'ordinate'
# end class OrdinatesZacrep


class OrdinateZacrep(GeneratedsSuper):
    """OrdinateZacrep -- К
    о
    о
    р
    д
    и
    н
    а
    т
    ы
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    x -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    X
    y -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    Y
    z -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    Z
    ord_nmb -- Н
    о
    м
    е
    р
    т
    о
    ч
    к
    и
    (
    п
    о
    р
    я
    д
    о
    к
    о
    б
    х
    о
    д
    а
    )
    num_geopoint -- Н
    о
    м
    е
    р
    м
    е
    ж
    е
    в
    о
    й
    т
    о
    ч
    к
    и
    geopoint_zacrep -- О
    п
    и
    с
    а
    н
    и
    е
    з
    а
    к
    р
    е
    п
    л
    е
    н
    и
    я
    т
    о
    ч
    к
    и
    delta_geopoint -- П
    о
    г
    р
    е
    ш
    н
    о
    с
    т
    ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, x=None, y=None, z=None, ord_nmb=None, num_geopoint=None, geopoint_zacrep=None, delta_geopoint=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.x = x
        self.x_nsprefix_ = None
        self.y = y
        self.y_nsprefix_ = None
        self.z = z
        self.z_nsprefix_ = None
        self.ord_nmb = ord_nmb
        self.ord_nmb_nsprefix_ = None
        self.num_geopoint = num_geopoint
        self.num_geopoint_nsprefix_ = None
        self.geopoint_zacrep = geopoint_zacrep
        self.geopoint_zacrep_nsprefix_ = None
        self.delta_geopoint = delta_geopoint
        self.delta_geopoint_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OrdinateZacrep)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OrdinateZacrep.subclass:
            return OrdinateZacrep.subclass(*args_, **kwargs_)
        else:
            return OrdinateZacrep(*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_x(self):
        return self.x
    def set_x(self, x):
        self.x = x
    def get_y(self):
        return self.y
    def set_y(self, y):
        self.y = y
    def get_z(self):
        return self.z
    def set_z(self, z):
        self.z = z
    def get_ord_nmb(self):
        return self.ord_nmb
    def set_ord_nmb(self, ord_nmb):
        self.ord_nmb = ord_nmb
    def get_num_geopoint(self):
        return self.num_geopoint
    def set_num_geopoint(self, num_geopoint):
        self.num_geopoint = num_geopoint
    def get_geopoint_zacrep(self):
        return self.geopoint_zacrep
    def set_geopoint_zacrep(self, geopoint_zacrep):
        self.geopoint_zacrep = geopoint_zacrep
    def get_delta_geopoint(self):
        return self.delta_geopoint
    def set_delta_geopoint(self, delta_geopoint):
        self.delta_geopoint = delta_geopoint
    def has__content(self):
        if (
            self.x is not None or
            self.y is not None or
            self.z is not None or
            self.ord_nmb is not None or
            self.num_geopoint is not None or
            self.geopoint_zacrep is not None or
            self.delta_geopoint is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinateZacrep', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OrdinateZacrep')
        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_ == 'OrdinateZacrep':
            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_='OrdinateZacrep')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OrdinateZacrep', 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_='OrdinateZacrep'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinateZacrep', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.x is not None:
            namespaceprefix_ = self.x_nsprefix_ + ':' if (UseCapturedNS_ and self.x_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sx>%s</%sx>%s' % (namespaceprefix_ , self.gds_format_decimal(self.x, input_name='x'), namespaceprefix_ , eol_))
        if self.y is not None:
            namespaceprefix_ = self.y_nsprefix_ + ':' if (UseCapturedNS_ and self.y_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sy>%s</%sy>%s' % (namespaceprefix_ , self.gds_format_decimal(self.y, input_name='y'), namespaceprefix_ , eol_))
        if self.z is not None:
            namespaceprefix_ = self.z_nsprefix_ + ':' if (UseCapturedNS_ and self.z_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sz>%s</%sz>%s' % (namespaceprefix_ , self.gds_format_decimal(self.z, input_name='z'), namespaceprefix_ , eol_))
        if self.ord_nmb is not None:
            namespaceprefix_ = self.ord_nmb_nsprefix_ + ':' if (UseCapturedNS_ and self.ord_nmb_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sord_nmb>%s</%sord_nmb>%s' % (namespaceprefix_ , self.gds_format_integer(self.ord_nmb, input_name='ord_nmb'), namespaceprefix_ , eol_))
        if self.num_geopoint is not None:
            namespaceprefix_ = self.num_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.num_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snum_geopoint>%s</%snum_geopoint>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.num_geopoint), input_name='num_geopoint')), namespaceprefix_ , eol_))
        if self.geopoint_zacrep is not None:
            namespaceprefix_ = self.geopoint_zacrep_nsprefix_ + ':' if (UseCapturedNS_ and self.geopoint_zacrep_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sgeopoint_zacrep>%s</%sgeopoint_zacrep>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.geopoint_zacrep), input_name='geopoint_zacrep')), namespaceprefix_ , eol_))
        if self.delta_geopoint is not None:
            namespaceprefix_ = self.delta_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdelta_geopoint>%s</%sdelta_geopoint>%s' % (namespaceprefix_ , self.gds_format_decimal(self.delta_geopoint, input_name='delta_geopoint'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'x' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'x')
            fval_ = self.gds_validate_decimal(fval_, node, 'x')
            self.x = fval_
            self.x_nsprefix_ = child_.prefix
        elif nodeName_ == 'y' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'y')
            fval_ = self.gds_validate_decimal(fval_, node, 'y')
            self.y = fval_
            self.y_nsprefix_ = child_.prefix
        elif nodeName_ == 'z' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'z')
            fval_ = self.gds_validate_decimal(fval_, node, 'z')
            self.z = fval_
            self.z_nsprefix_ = child_.prefix
        elif nodeName_ == 'ord_nmb' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'ord_nmb')
            ival_ = self.gds_validate_integer(ival_, node, 'ord_nmb')
            self.ord_nmb = ival_
            self.ord_nmb_nsprefix_ = child_.prefix
        elif nodeName_ == 'num_geopoint':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'num_geopoint')
            value_ = self.gds_validate_string(value_, node, 'num_geopoint')
            self.num_geopoint = value_
            self.num_geopoint_nsprefix_ = child_.prefix
        elif nodeName_ == 'geopoint_zacrep':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'geopoint_zacrep')
            value_ = self.gds_validate_string(value_, node, 'geopoint_zacrep')
            self.geopoint_zacrep = value_
            self.geopoint_zacrep_nsprefix_ = child_.prefix
        elif nodeName_ == 'delta_geopoint' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'delta_geopoint')
            fval_ = self.gds_validate_decimal(fval_, node, 'delta_geopoint')
            self.delta_geopoint = fval_
            self.delta_geopoint_nsprefix_ = child_.prefix
# end class OrdinateZacrep


class Borders(GeneratedsSuper):
    """Borders -- О
    п
    и
    с
    а
    н
    и
    е
    г
    р
    а
    н
    и
    ц
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    (
    о
    т
    т
    о
    ч
    к
    и
    д
    о
    т
    о
    ч
    к
    и
    )
    и
    н
    а
    л
    и
    ч
    и
    е
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    с
    п
    о
    р
    а
    border -- Ч
    а
    с
    т
    ь
    г
    р
    а
    н
    и
    ц
    ы
    (
    о
    т
    т
    о
    ч
    к
    и
    д
    о
    т
    о
    ч
    к
    и
    )
    и
    н
    а
    л
    и
    ч
    и
    е
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    с
    п
    о
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, border=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 border is None:
            self.border = []
        else:
            self.border = border
        self.border_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Borders)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Borders.subclass:
            return Borders.subclass(*args_, **kwargs_)
        else:
            return Borders(*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_border(self):
        return self.border
    def set_border(self, border):
        self.border = border
    def add_border(self, value):
        self.border.append(value)
    def insert_border_at(self, index, value):
        self.border.insert(index, value)
    def replace_border_at(self, index, value):
        self.border[index] = value
    def has__content(self):
        if (
            self.border
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Borders', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Borders')
        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_ == 'Borders':
            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_='Borders')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Borders', 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_='Borders'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Borders', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for border_ in self.border:
            namespaceprefix_ = self.border_nsprefix_ + ':' if (UseCapturedNS_ and self.border_nsprefix_) else ''
            border_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='border', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'border':
            obj_ = BorderlandDisput.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.border.append(obj_)
            obj_.original_tagname_ = 'border'
# end class Borders


class BorderlandDisput(GeneratedsSuper):
    """BorderlandDisput -- Ч
    а
    с
    т
    ь
    г
    р
    а
    н
    и
    ц
    ы
    (
    о
    т
    т
    о
    ч
    к
    и
    д
    о
    т
    о
    ч
    к
    и
    )
    и
    н
    а
    л
    и
    ч
    и
    е
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    с
    п
    о
    р
    а
    by_definition -- Ч
    а
    с
    т
    ь
    г
    р
    а
    н
    и
    ц
    ы
    (
    о
    т
    т
    о
    ч
    к
    и
    д
    о
    т
    о
    ч
    к
    и
    )
    п
    о
    о
    п
    и
    с
    а
    н
    и
    ю
    geopoint_zacrep -- О
    п
    и
    с
    а
    н
    и
    е
    з
    а
    к
    р
    е
    п
    л
    е
    н
    и
    я
    н
    а
    м
    е
    с
    т
    н
    о
    с
    т
    и
    direction_angle -- Д
    и
    р
    е
    к
    ц
    и
    о
    н
    н
    ы
    й
    у
    г
    о
    л
    horizontal_distance -- Г
    о
    р
    и
    з
    о
    н
    т
    а
    л
    ь
    н
    о
    е
    п
    р
    о
    л
    о
    ж
    е
    н
    и
    е
    ,
    м
    cadastral_numbs_adjacent_parcels -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    с
    м
    е
    ж
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    holders_related_lands -- А
    д
    р
    е
    с
    а
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    е
    й
    с
    м
    е
    ж
    н
    ы
    х
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    land_disput -- З
    е
    м
    е
    л
    ь
    н
    ы
    й
    с
    п
    о
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, by_definition=None, geopoint_zacrep=None, direction_angle=None, horizontal_distance=None, cadastral_numbs_adjacent_parcels=None, holders_related_lands=None, land_disput=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.by_definition = by_definition
        self.by_definition_nsprefix_ = None
        self.geopoint_zacrep = geopoint_zacrep
        self.geopoint_zacrep_nsprefix_ = None
        self.direction_angle = direction_angle
        self.direction_angle_nsprefix_ = None
        self.horizontal_distance = horizontal_distance
        self.horizontal_distance_nsprefix_ = None
        self.cadastral_numbs_adjacent_parcels = cadastral_numbs_adjacent_parcels
        self.cadastral_numbs_adjacent_parcels_nsprefix_ = None
        self.holders_related_lands = holders_related_lands
        self.holders_related_lands_nsprefix_ = None
        self.land_disput = land_disput
        self.land_disput_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BorderlandDisput)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BorderlandDisput.subclass:
            return BorderlandDisput.subclass(*args_, **kwargs_)
        else:
            return BorderlandDisput(*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_by_definition(self):
        return self.by_definition
    def set_by_definition(self, by_definition):
        self.by_definition = by_definition
    def get_geopoint_zacrep(self):
        return self.geopoint_zacrep
    def set_geopoint_zacrep(self, geopoint_zacrep):
        self.geopoint_zacrep = geopoint_zacrep
    def get_direction_angle(self):
        return self.direction_angle
    def set_direction_angle(self, direction_angle):
        self.direction_angle = direction_angle
    def get_horizontal_distance(self):
        return self.horizontal_distance
    def set_horizontal_distance(self, horizontal_distance):
        self.horizontal_distance = horizontal_distance
    def get_cadastral_numbs_adjacent_parcels(self):
        return self.cadastral_numbs_adjacent_parcels
    def set_cadastral_numbs_adjacent_parcels(self, cadastral_numbs_adjacent_parcels):
        self.cadastral_numbs_adjacent_parcels = cadastral_numbs_adjacent_parcels
    def get_holders_related_lands(self):
        return self.holders_related_lands
    def set_holders_related_lands(self, holders_related_lands):
        self.holders_related_lands = holders_related_lands
    def get_land_disput(self):
        return self.land_disput
    def set_land_disput(self, land_disput):
        self.land_disput = land_disput
    def has__content(self):
        if (
            self.by_definition is not None or
            self.geopoint_zacrep is not None or
            self.direction_angle is not None or
            self.horizontal_distance is not None or
            self.cadastral_numbs_adjacent_parcels is not None or
            self.holders_related_lands is not None or
            self.land_disput is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BorderlandDisput', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BorderlandDisput')
        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_ == 'BorderlandDisput':
            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_='BorderlandDisput')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BorderlandDisput', 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_='BorderlandDisput'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BorderlandDisput', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.by_definition is not None:
            namespaceprefix_ = self.by_definition_nsprefix_ + ':' if (UseCapturedNS_ and self.by_definition_nsprefix_) else ''
            self.by_definition.export(outfile, level, namespaceprefix_, namespacedef_='', name_='by_definition', pretty_print=pretty_print)
        if self.geopoint_zacrep is not None:
            namespaceprefix_ = self.geopoint_zacrep_nsprefix_ + ':' if (UseCapturedNS_ and self.geopoint_zacrep_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sgeopoint_zacrep>%s</%sgeopoint_zacrep>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.geopoint_zacrep), input_name='geopoint_zacrep')), namespaceprefix_ , eol_))
        if self.direction_angle is not None:
            namespaceprefix_ = self.direction_angle_nsprefix_ + ':' if (UseCapturedNS_ and self.direction_angle_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdirection_angle>%s</%sdirection_angle>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.direction_angle), input_name='direction_angle')), namespaceprefix_ , eol_))
        if self.horizontal_distance is not None:
            namespaceprefix_ = self.horizontal_distance_nsprefix_ + ':' if (UseCapturedNS_ and self.horizontal_distance_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%shorizontal_distance>%s</%shorizontal_distance>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.horizontal_distance), input_name='horizontal_distance')), namespaceprefix_ , eol_))
        if self.cadastral_numbs_adjacent_parcels is not None:
            namespaceprefix_ = self.cadastral_numbs_adjacent_parcels_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_numbs_adjacent_parcels_nsprefix_) else ''
            self.cadastral_numbs_adjacent_parcels.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cadastral_numbs_adjacent_parcels', pretty_print=pretty_print)
        if self.holders_related_lands is not None:
            namespaceprefix_ = self.holders_related_lands_nsprefix_ + ':' if (UseCapturedNS_ and self.holders_related_lands_nsprefix_) else ''
            self.holders_related_lands.export(outfile, level, namespaceprefix_, namespacedef_='', name_='holders_related_lands', pretty_print=pretty_print)
        if self.land_disput is not None:
            namespaceprefix_ = self.land_disput_nsprefix_ + ':' if (UseCapturedNS_ and self.land_disput_nsprefix_) else ''
            self.land_disput.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_disput', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'by_definition':
            obj_ = Border.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.by_definition = obj_
            obj_.original_tagname_ = 'by_definition'
        elif nodeName_ == 'geopoint_zacrep':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'geopoint_zacrep')
            value_ = self.gds_validate_string(value_, node, 'geopoint_zacrep')
            self.geopoint_zacrep = value_
            self.geopoint_zacrep_nsprefix_ = child_.prefix
        elif nodeName_ == 'direction_angle':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'direction_angle')
            value_ = self.gds_validate_string(value_, node, 'direction_angle')
            self.direction_angle = value_
            self.direction_angle_nsprefix_ = child_.prefix
        elif nodeName_ == 'horizontal_distance':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'horizontal_distance')
            value_ = self.gds_validate_string(value_, node, 'horizontal_distance')
            self.horizontal_distance = value_
            self.horizontal_distance_nsprefix_ = child_.prefix
        elif nodeName_ == 'cadastral_numbs_adjacent_parcels':
            obj_ = CadastralNumbsAdjacentParcels.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cadastral_numbs_adjacent_parcels = obj_
            obj_.original_tagname_ = 'cadastral_numbs_adjacent_parcels'
        elif nodeName_ == 'holders_related_lands':
            obj_ = HoldersRelatedLands.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.holders_related_lands = obj_
            obj_.original_tagname_ = 'holders_related_lands'
        elif nodeName_ == 'land_disput':
            obj_ = LandDisput.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_disput = obj_
            obj_.original_tagname_ = 'land_disput'
# end class BorderlandDisput


class CadastralNumbsAdjacentParcels(GeneratedsSuper):
    """CadastralNumbsAdjacentParcels -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    с
    м
    е
    ж
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    cadastral_numb_adjacent_parcel -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    с
    м
    е
    ж
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cadastral_numb_adjacent_parcel=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 cadastral_numb_adjacent_parcel is None:
            self.cadastral_numb_adjacent_parcel = []
        else:
            self.cadastral_numb_adjacent_parcel = cadastral_numb_adjacent_parcel
        self.cadastral_numb_adjacent_parcel_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadastralNumbsAdjacentParcels)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadastralNumbsAdjacentParcels.subclass:
            return CadastralNumbsAdjacentParcels.subclass(*args_, **kwargs_)
        else:
            return CadastralNumbsAdjacentParcels(*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_cadastral_numb_adjacent_parcel(self):
        return self.cadastral_numb_adjacent_parcel
    def set_cadastral_numb_adjacent_parcel(self, cadastral_numb_adjacent_parcel):
        self.cadastral_numb_adjacent_parcel = cadastral_numb_adjacent_parcel
    def add_cadastral_numb_adjacent_parcel(self, value):
        self.cadastral_numb_adjacent_parcel.append(value)
    def insert_cadastral_numb_adjacent_parcel_at(self, index, value):
        self.cadastral_numb_adjacent_parcel.insert(index, value)
    def replace_cadastral_numb_adjacent_parcel_at(self, index, value):
        self.cadastral_numb_adjacent_parcel[index] = value
    def has__content(self):
        if (
            self.cadastral_numb_adjacent_parcel
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadastralNumbsAdjacentParcels', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadastralNumbsAdjacentParcels')
        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_ == 'CadastralNumbsAdjacentParcels':
            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_='CadastralNumbsAdjacentParcels')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadastralNumbsAdjacentParcels', 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_='CadastralNumbsAdjacentParcels'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadastralNumbsAdjacentParcels', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for cadastral_numb_adjacent_parcel_ in self.cadastral_numb_adjacent_parcel:
            namespaceprefix_ = self.cadastral_numb_adjacent_parcel_nsprefix_ + ':' if (UseCapturedNS_ and self.cadastral_numb_adjacent_parcel_nsprefix_) else ''
            cadastral_numb_adjacent_parcel_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cadastral_numb_adjacent_parcel', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cadastral_numb_adjacent_parcel':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cadastral_numb_adjacent_parcel.append(obj_)
            obj_.original_tagname_ = 'cadastral_numb_adjacent_parcel'
# end class CadastralNumbsAdjacentParcels


class HoldersRelatedLands(GeneratedsSuper):
    """HoldersRelatedLands -- А
    д
    р
    е
    с
    а
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    е
    й
    с
    м
    е
    ж
    н
    ы
    х
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    holder_related_land -- А
    д
    р
    е
    с
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    с
    м
    е
    ж
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, holder_related_land=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 holder_related_land is None:
            self.holder_related_land = []
        else:
            self.holder_related_land = holder_related_land
        self.holder_related_land_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, HoldersRelatedLands)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if HoldersRelatedLands.subclass:
            return HoldersRelatedLands.subclass(*args_, **kwargs_)
        else:
            return HoldersRelatedLands(*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_holder_related_land(self):
        return self.holder_related_land
    def set_holder_related_land(self, holder_related_land):
        self.holder_related_land = holder_related_land
    def add_holder_related_land(self, value):
        self.holder_related_land.append(value)
    def insert_holder_related_land_at(self, index, value):
        self.holder_related_land.insert(index, value)
    def replace_holder_related_land_at(self, index, value):
        self.holder_related_land[index] = value
    def has__content(self):
        if (
            self.holder_related_land
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='HoldersRelatedLands', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('HoldersRelatedLands')
        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_ == 'HoldersRelatedLands':
            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_='HoldersRelatedLands')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='HoldersRelatedLands', 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_='HoldersRelatedLands'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='HoldersRelatedLands', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for holder_related_land_ in self.holder_related_land:
            namespaceprefix_ = self.holder_related_land_nsprefix_ + ':' if (UseCapturedNS_ and self.holder_related_land_nsprefix_) else ''
            holder_related_land_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='holder_related_land', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'holder_related_land':
            obj_ = Contacts.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.holder_related_land.append(obj_)
            obj_.original_tagname_ = 'holder_related_land'
# end class HoldersRelatedLands


class LandDisput(GeneratedsSuper):
    """LandDisput -- З
    е
    м
    е
    л
    ь
    н
    ы
    й
    с
    п
    о
    р
    approoval_act_requisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    а
    к
    т
    а
    о
    б
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    и
    и
    к
    а
    р
    т
    ы
    -
    п
    л
    а
    н
    а
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    dispute_cancel_date -- Д
    а
    т
    а
    о
    к
    о
    н
    ч
    а
    н
    и
    я
    к
    о
    н
    т
    р
    о
    л
    ь
    н
    о
    г
    о
    с
    р
    о
    к
    а
    д
    е
    й
    с
    т
    в
    и
    я
    о
    т
    м
    е
    т
    к
    и
    о
    н
    а
    л
    и
    ч
    и
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    с
    п
    о
    р
    а
    number_contour -- Н
    о
    м
    е
    р
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, approoval_act_requisites=None, dispute_cancel_date=None, number_contour=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.approoval_act_requisites = approoval_act_requisites
        self.approoval_act_requisites_nsprefix_ = None
        if isinstance(dispute_cancel_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(dispute_cancel_date, '%Y-%m-%d').date()
        else:
            initvalue_ = dispute_cancel_date
        self.dispute_cancel_date = initvalue_
        self.dispute_cancel_date_nsprefix_ = None
        self.number_contour = number_contour
        self.number_contour_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LandDisput)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LandDisput.subclass:
            return LandDisput.subclass(*args_, **kwargs_)
        else:
            return LandDisput(*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_approoval_act_requisites(self):
        return self.approoval_act_requisites
    def set_approoval_act_requisites(self, approoval_act_requisites):
        self.approoval_act_requisites = approoval_act_requisites
    def get_dispute_cancel_date(self):
        return self.dispute_cancel_date
    def set_dispute_cancel_date(self, dispute_cancel_date):
        self.dispute_cancel_date = dispute_cancel_date
    def get_number_contour(self):
        return self.number_contour
    def set_number_contour(self, number_contour):
        self.number_contour = number_contour
    def has__content(self):
        if (
            self.approoval_act_requisites is not None or
            self.dispute_cancel_date is not None or
            self.number_contour is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandDisput', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LandDisput')
        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_ == 'LandDisput':
            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_='LandDisput')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LandDisput', 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_='LandDisput'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LandDisput', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.approoval_act_requisites is not None:
            namespaceprefix_ = self.approoval_act_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.approoval_act_requisites_nsprefix_) else ''
            self.approoval_act_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='approoval_act_requisites', pretty_print=pretty_print)
        if self.dispute_cancel_date is not None:
            namespaceprefix_ = self.dispute_cancel_date_nsprefix_ + ':' if (UseCapturedNS_ and self.dispute_cancel_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdispute_cancel_date>%s</%sdispute_cancel_date>%s' % (namespaceprefix_ , self.gds_format_date(self.dispute_cancel_date, input_name='dispute_cancel_date'), namespaceprefix_ , eol_))
        if self.number_contour is not None:
            namespaceprefix_ = self.number_contour_nsprefix_ + ':' if (UseCapturedNS_ and self.number_contour_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_contour>%s</%snumber_contour>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number_contour), input_name='number_contour')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'approoval_act_requisites':
            obj_ = DocRequisiteMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.approoval_act_requisites = obj_
            obj_.original_tagname_ = 'approoval_act_requisites'
        elif nodeName_ == 'dispute_cancel_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.dispute_cancel_date = dval_
            self.dispute_cancel_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'number_contour':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'number_contour')
            value_ = self.gds_validate_string(value_, node, 'number_contour')
            self.number_contour = value_
            self.number_contour_nsprefix_ = child_.prefix
# end class LandDisput


class Border(GeneratedsSuper):
    """Border -- О
    п
    и
    с
    а
    н
    и
    е
    г
    р
    а
    н
    и
    ц
    ы
    (
    о
    т
    т
    о
    ч
    к
    и
    д
    о
    т
    о
    ч
    к
    и
    )
    nmb_contour -- Н
    о
    м
    е
    р
    к
    о
    н
    т
    у
    р
    а
    spatial_element -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    э
    л
    е
    м
    е
    н
    т
    а
    к
    о
    н
    т
    у
    р
    а
    point1 -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    т
    о
    ч
    к
    и
    1
    в
    э
    л
    е
    м
    е
    н
    т
    е
    point2 -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    т
    о
    ч
    к
    и
    2
    в
    э
    л
    е
    м
    е
    н
    т
    е
    definition -- О
    п
    и
    с
    а
    н
    и
    е
    г
    р
    а
    н
    и
    ц
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, nmb_contour=None, spatial_element=None, point1=None, point2=None, definition=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.nmb_contour = nmb_contour
        self.nmb_contour_nsprefix_ = None
        self.spatial_element = spatial_element
        self.spatial_element_nsprefix_ = None
        self.point1 = point1
        self.point1_nsprefix_ = None
        self.point2 = point2
        self.point2_nsprefix_ = None
        self.definition = definition
        self.validate_MultiLiner(self.definition)
        self.definition_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Border)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Border.subclass:
            return Border.subclass(*args_, **kwargs_)
        else:
            return Border(*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_nmb_contour(self):
        return self.nmb_contour
    def set_nmb_contour(self, nmb_contour):
        self.nmb_contour = nmb_contour
    def get_spatial_element(self):
        return self.spatial_element
    def set_spatial_element(self, spatial_element):
        self.spatial_element = spatial_element
    def get_point1(self):
        return self.point1
    def set_point1(self, point1):
        self.point1 = point1
    def get_point2(self):
        return self.point2
    def set_point2(self, point2):
        self.point2 = point2
    def get_definition(self):
        return self.definition
    def set_definition(self, definition):
        self.definition = definition
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.nmb_contour is not None or
            self.spatial_element is not None or
            self.point1 is not None or
            self.point2 is not None or
            self.definition is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Border', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Border')
        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_ == 'Border':
            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_='Border')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Border', 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_='Border'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Border', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.nmb_contour is not None:
            namespaceprefix_ = self.nmb_contour_nsprefix_ + ':' if (UseCapturedNS_ and self.nmb_contour_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snmb_contour>%s</%snmb_contour>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.nmb_contour), input_name='nmb_contour')), namespaceprefix_ , eol_))
        if self.spatial_element is not None:
            namespaceprefix_ = self.spatial_element_nsprefix_ + ':' if (UseCapturedNS_ and self.spatial_element_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sspatial_element>%s</%sspatial_element>%s' % (namespaceprefix_ , self.gds_format_integer(self.spatial_element, input_name='spatial_element'), namespaceprefix_ , eol_))
        if self.point1 is not None:
            namespaceprefix_ = self.point1_nsprefix_ + ':' if (UseCapturedNS_ and self.point1_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spoint1>%s</%spoint1>%s' % (namespaceprefix_ , self.gds_format_integer(self.point1, input_name='point1'), namespaceprefix_ , eol_))
        if self.point2 is not None:
            namespaceprefix_ = self.point2_nsprefix_ + ':' if (UseCapturedNS_ and self.point2_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spoint2>%s</%spoint2>%s' % (namespaceprefix_ , self.gds_format_integer(self.point2, input_name='point2'), namespaceprefix_ , eol_))
        if self.definition is not None:
            namespaceprefix_ = self.definition_nsprefix_ + ':' if (UseCapturedNS_ and self.definition_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdefinition>%s</%sdefinition>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.definition), input_name='definition')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'nmb_contour':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'nmb_contour')
            value_ = self.gds_validate_string(value_, node, 'nmb_contour')
            self.nmb_contour = value_
            self.nmb_contour_nsprefix_ = child_.prefix
        elif nodeName_ == 'spatial_element' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'spatial_element')
            ival_ = self.gds_validate_integer(ival_, node, 'spatial_element')
            self.spatial_element = ival_
            self.spatial_element_nsprefix_ = child_.prefix
        elif nodeName_ == 'point1' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'point1')
            ival_ = self.gds_validate_integer(ival_, node, 'point1')
            self.point1 = ival_
            self.point1_nsprefix_ = child_.prefix
        elif nodeName_ == 'point2' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'point2')
            ival_ = self.gds_validate_integer(ival_, node, 'point2')
            self.point2 = ival_
            self.point2_nsprefix_ = child_.prefix
        elif nodeName_ == 'definition':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'definition')
            value_ = self.gds_validate_string(value_, node, 'definition')
            self.definition = value_
            self.definition_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.definition)
# end class Border


class ContoursOKSOut(GeneratedsSuper):
    """ContoursOKSOut -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    contour -- К
    о
    н
    т
    у
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, contour=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 contour is None:
            self.contour = []
        else:
            self.contour = contour
        self.contour_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContoursOKSOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContoursOKSOut.subclass:
            return ContoursOKSOut.subclass(*args_, **kwargs_)
        else:
            return ContoursOKSOut(*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_contour(self):
        return self.contour
    def set_contour(self, contour):
        self.contour = contour
    def add_contour(self, value):
        self.contour.append(value)
    def insert_contour_at(self, index, value):
        self.contour.insert(index, value)
    def replace_contour_at(self, index, value):
        self.contour[index] = value
    def has__content(self):
        if (
            self.contour
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursOKSOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContoursOKSOut')
        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_ == 'ContoursOKSOut':
            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_='ContoursOKSOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContoursOKSOut', 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_='ContoursOKSOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursOKSOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for contour_ in self.contour:
            namespaceprefix_ = self.contour_nsprefix_ + ':' if (UseCapturedNS_ and self.contour_nsprefix_) else ''
            contour_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contour', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'contour':
            obj_ = ContourOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contour.append(obj_)
            obj_.original_tagname_ = 'contour'
# end class ContoursOKSOut


class ContourOKSOut(GeneratedsSuper):
    """ContourOKSOut -- К
    о
    н
    т
    у
    р
    О
    К
    С
    number_pp -- Н
    о
    м
    е
    р
    к
    о
    н
    т
    у
    р
    а
    entity_spatial -- О
    п
    и
    с
    а
    н
    и
    е
    э
    л
    е
    м
    е
    н
    т
    о
    в
    к
    о
    н
    т
    у
    р
    а
    (
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_pp=None, entity_spatial=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.number_pp = number_pp
        self.number_pp_nsprefix_ = None
        self.entity_spatial = entity_spatial
        self.entity_spatial_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContourOKSOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContourOKSOut.subclass:
            return ContourOKSOut.subclass(*args_, **kwargs_)
        else:
            return ContourOKSOut(*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_pp(self):
        return self.number_pp
    def set_number_pp(self, number_pp):
        self.number_pp = number_pp
    def get_entity_spatial(self):
        return self.entity_spatial
    def set_entity_spatial(self, entity_spatial):
        self.entity_spatial = entity_spatial
    def has__content(self):
        if (
            self.number_pp is not None or
            self.entity_spatial is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContourOKSOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContourOKSOut')
        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_ == 'ContourOKSOut':
            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_='ContourOKSOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContourOKSOut', 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_='ContourOKSOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContourOKSOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_pp is not None:
            namespaceprefix_ = self.number_pp_nsprefix_ + ':' if (UseCapturedNS_ and self.number_pp_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_pp>%s</%snumber_pp>%s' % (namespaceprefix_ , self.gds_format_integer(self.number_pp, input_name='number_pp'), namespaceprefix_ , eol_))
        if self.entity_spatial is not None:
            namespaceprefix_ = self.entity_spatial_nsprefix_ + ':' if (UseCapturedNS_ and self.entity_spatial_nsprefix_) else ''
            self.entity_spatial.export(outfile, level, namespaceprefix_, namespacedef_='', name_='entity_spatial', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_pp' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'number_pp')
            ival_ = self.gds_validate_integer(ival_, node, 'number_pp')
            self.number_pp = ival_
            self.number_pp_nsprefix_ = child_.prefix
        elif nodeName_ == 'entity_spatial':
            obj_ = EntitySpatialOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.entity_spatial = obj_
            obj_.original_tagname_ = 'entity_spatial'
# end class ContourOKSOut


class ContoursLocationOKSOut(GeneratedsSuper):
    """ContoursLocationOKSOut -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    )
    contours -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, contours=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.object = object
        self.object_nsprefix_ = None
        self.contours = contours
        self.contours_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ContoursLocationOKSOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ContoursLocationOKSOut.subclass:
            return ContoursLocationOKSOut.subclass(*args_, **kwargs_)
        else:
            return ContoursLocationOKSOut(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def has__content(self):
        if (
            self.object is not None or
            self.contours is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursLocationOKSOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ContoursLocationOKSOut')
        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_ == 'ContoursLocationOKSOut':
            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_='ContoursLocationOKSOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ContoursLocationOKSOut', 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_='ContoursLocationOKSOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ContoursLocationOKSOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectCadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'contours':
            obj_ = ContoursOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
# end class ContoursLocationOKSOut


class EntitySpatialOKSOut(GeneratedsSuper):
    """EntitySpatialOKSOut -- О
    п
    и
    с
    а
    н
    и
    е
    э
    л
    е
    м
    е
    н
    т
    о
    в
    к
    о
    т
    н
    у
    р
    а
    sk_id -- С
    и
    с
    т
    е
    м
    а
    к
    о
    о
    р
    д
    и
    н
    а
    т
    spatials_elements -- Э
    л
    е
    м
    е
    н
    т
    ы
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, sk_id=None, spatials_elements=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.sk_id = sk_id
        self.sk_id_nsprefix_ = None
        self.spatials_elements = spatials_elements
        self.spatials_elements_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, EntitySpatialOKSOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if EntitySpatialOKSOut.subclass:
            return EntitySpatialOKSOut.subclass(*args_, **kwargs_)
        else:
            return EntitySpatialOKSOut(*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_sk_id(self):
        return self.sk_id
    def set_sk_id(self, sk_id):
        self.sk_id = sk_id
    def get_spatials_elements(self):
        return self.spatials_elements
    def set_spatials_elements(self, spatials_elements):
        self.spatials_elements = spatials_elements
    def has__content(self):
        if (
            self.sk_id is not None or
            self.spatials_elements is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntitySpatialOKSOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('EntitySpatialOKSOut')
        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_ == 'EntitySpatialOKSOut':
            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_='EntitySpatialOKSOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='EntitySpatialOKSOut', 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_='EntitySpatialOKSOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntitySpatialOKSOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.sk_id is not None:
            namespaceprefix_ = self.sk_id_nsprefix_ + ':' if (UseCapturedNS_ and self.sk_id_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssk_id>%s</%ssk_id>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.sk_id), input_name='sk_id')), namespaceprefix_ , eol_))
        if self.spatials_elements is not None:
            namespaceprefix_ = self.spatials_elements_nsprefix_ + ':' if (UseCapturedNS_ and self.spatials_elements_nsprefix_) else ''
            self.spatials_elements.export(outfile, level, namespaceprefix_, namespacedef_='', name_='spatials_elements', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'sk_id':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'sk_id')
            value_ = self.gds_validate_string(value_, node, 'sk_id')
            self.sk_id = value_
            self.sk_id_nsprefix_ = child_.prefix
        elif nodeName_ == 'spatials_elements':
            obj_ = SpatialsElementsOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.spatials_elements = obj_
            obj_.original_tagname_ = 'spatials_elements'
# end class EntitySpatialOKSOut


class SpatialsElementsOKSOut(GeneratedsSuper):
    """SpatialsElementsOKSOut -- Э
    л
    е
    м
    е
    н
    т
    ы
    к
    о
    н
    т
    у
    р
    а
    О
    К
    С
    spatial_element -- Э
    л
    е
    м
    е
    н
    т
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, spatial_element=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 spatial_element is None:
            self.spatial_element = []
        else:
            self.spatial_element = spatial_element
        self.spatial_element_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpatialsElementsOKSOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpatialsElementsOKSOut.subclass:
            return SpatialsElementsOKSOut.subclass(*args_, **kwargs_)
        else:
            return SpatialsElementsOKSOut(*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_spatial_element(self):
        return self.spatial_element
    def set_spatial_element(self, spatial_element):
        self.spatial_element = spatial_element
    def add_spatial_element(self, value):
        self.spatial_element.append(value)
    def insert_spatial_element_at(self, index, value):
        self.spatial_element.insert(index, value)
    def replace_spatial_element_at(self, index, value):
        self.spatial_element[index] = value
    def has__content(self):
        if (
            self.spatial_element
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialsElementsOKSOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpatialsElementsOKSOut')
        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_ == 'SpatialsElementsOKSOut':
            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_='SpatialsElementsOKSOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpatialsElementsOKSOut', 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_='SpatialsElementsOKSOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialsElementsOKSOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for spatial_element_ in self.spatial_element:
            namespaceprefix_ = self.spatial_element_nsprefix_ + ':' if (UseCapturedNS_ and self.spatial_element_nsprefix_) else ''
            spatial_element_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='spatial_element', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'spatial_element':
            obj_ = SpatialElementOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.spatial_element.append(obj_)
            obj_.original_tagname_ = 'spatial_element'
# end class SpatialsElementsOKSOut


class SpatialElementOKSOut(GeneratedsSuper):
    """SpatialElementOKSOut -- Э
    л
    е
    м
    е
    н
    т
    к
    о
    н
    т
    у
    р
    а
    level_contour -- Т
    и
    п
    к
    о
    н
    т
    у
    р
    а
    (
    у
    р
    о
    в
    е
    н
    ь
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    )
    ordinates -- С
    п
    и
    с
    о
    к
    к
    о
    о
    р
    д
    и
    н
    а
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, level_contour=None, ordinates=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.level_contour = level_contour
        self.level_contour_nsprefix_ = None
        self.ordinates = ordinates
        self.ordinates_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpatialElementOKSOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpatialElementOKSOut.subclass:
            return SpatialElementOKSOut.subclass(*args_, **kwargs_)
        else:
            return SpatialElementOKSOut(*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_level_contour(self):
        return self.level_contour
    def set_level_contour(self, level_contour):
        self.level_contour = level_contour
    def get_ordinates(self):
        return self.ordinates
    def set_ordinates(self, ordinates):
        self.ordinates = ordinates
    def has__content(self):
        if (
            self.level_contour is not None or
            self.ordinates is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialElementOKSOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpatialElementOKSOut')
        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_ == 'SpatialElementOKSOut':
            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_='SpatialElementOKSOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpatialElementOKSOut', 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_='SpatialElementOKSOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialElementOKSOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.level_contour is not None:
            namespaceprefix_ = self.level_contour_nsprefix_ + ':' if (UseCapturedNS_ and self.level_contour_nsprefix_) else ''
            self.level_contour.export(outfile, level, namespaceprefix_, namespacedef_='', name_='level_contour', pretty_print=pretty_print)
        if self.ordinates is not None:
            namespaceprefix_ = self.ordinates_nsprefix_ + ':' if (UseCapturedNS_ and self.ordinates_nsprefix_) else ''
            self.ordinates.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ordinates', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'level_contour':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.level_contour = obj_
            obj_.original_tagname_ = 'level_contour'
        elif nodeName_ == 'ordinates':
            obj_ = OrdinatesOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ordinates = obj_
            obj_.original_tagname_ = 'ordinates'
# end class SpatialElementOKSOut


class OrdinatesOKSOut(GeneratedsSuper):
    """OrdinatesOKSOut -- С
    п
    и
    с
    о
    к
    к
    о
    о
    р
    д
    и
    н
    а
    т
    ordinate -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ordinate=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 ordinate is None:
            self.ordinate = []
        else:
            self.ordinate = ordinate
        self.ordinate_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OrdinatesOKSOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OrdinatesOKSOut.subclass:
            return OrdinatesOKSOut.subclass(*args_, **kwargs_)
        else:
            return OrdinatesOKSOut(*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_ordinate(self):
        return self.ordinate
    def set_ordinate(self, ordinate):
        self.ordinate = ordinate
    def add_ordinate(self, value):
        self.ordinate.append(value)
    def insert_ordinate_at(self, index, value):
        self.ordinate.insert(index, value)
    def replace_ordinate_at(self, index, value):
        self.ordinate[index] = value
    def has__content(self):
        if (
            self.ordinate
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinatesOKSOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OrdinatesOKSOut')
        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_ == 'OrdinatesOKSOut':
            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_='OrdinatesOKSOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OrdinatesOKSOut', 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_='OrdinatesOKSOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinatesOKSOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ordinate_ in self.ordinate:
            namespaceprefix_ = self.ordinate_nsprefix_ + ':' if (UseCapturedNS_ and self.ordinate_nsprefix_) else ''
            ordinate_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ordinate', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ordinate':
            obj_ = OrdinateOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ordinate.append(obj_)
            obj_.original_tagname_ = 'ordinate'
# end class OrdinatesOKSOut


class OrdinateOKSOut(GeneratedsSuper):
    """OrdinateOKSOut -- К
    о
    о
    р
    д
    и
    н
    а
    т
    ы
    к
    о
    н
    т
    у
    р
    а
    О
    К
    С
    x -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    X
    y -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    Y
    z -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    Z
    ord_nmb -- Н
    о
    м
    е
    р
    т
    о
    ч
    к
    и
    (
    п
    о
    р
    я
    д
    о
    к
    о
    б
    х
    о
    д
    а
    )
    num_geopoint -- Н
    о
    м
    е
    р
    т
    о
    ч
    к
    и
    delta_geopoint -- П
    о
    г
    р
    е
    ш
    н
    о
    с
    т
    ь
    r -- Р
    а
    д
    и
    у
    с
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, x=None, y=None, z=None, ord_nmb=None, num_geopoint=None, delta_geopoint=None, r=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.x = x
        self.x_nsprefix_ = None
        self.y = y
        self.y_nsprefix_ = None
        self.z = z
        self.z_nsprefix_ = None
        self.ord_nmb = ord_nmb
        self.ord_nmb_nsprefix_ = None
        self.num_geopoint = num_geopoint
        self.num_geopoint_nsprefix_ = None
        self.delta_geopoint = delta_geopoint
        self.delta_geopoint_nsprefix_ = None
        self.r = r
        self.r_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OrdinateOKSOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OrdinateOKSOut.subclass:
            return OrdinateOKSOut.subclass(*args_, **kwargs_)
        else:
            return OrdinateOKSOut(*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_x(self):
        return self.x
    def set_x(self, x):
        self.x = x
    def get_y(self):
        return self.y
    def set_y(self, y):
        self.y = y
    def get_z(self):
        return self.z
    def set_z(self, z):
        self.z = z
    def get_ord_nmb(self):
        return self.ord_nmb
    def set_ord_nmb(self, ord_nmb):
        self.ord_nmb = ord_nmb
    def get_num_geopoint(self):
        return self.num_geopoint
    def set_num_geopoint(self, num_geopoint):
        self.num_geopoint = num_geopoint
    def get_delta_geopoint(self):
        return self.delta_geopoint
    def set_delta_geopoint(self, delta_geopoint):
        self.delta_geopoint = delta_geopoint
    def get_r(self):
        return self.r
    def set_r(self, r):
        self.r = r
    def has__content(self):
        if (
            self.x is not None or
            self.y is not None or
            self.z is not None or
            self.ord_nmb is not None or
            self.num_geopoint is not None or
            self.delta_geopoint is not None or
            self.r is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinateOKSOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OrdinateOKSOut')
        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_ == 'OrdinateOKSOut':
            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_='OrdinateOKSOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OrdinateOKSOut', 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_='OrdinateOKSOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinateOKSOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.x is not None:
            namespaceprefix_ = self.x_nsprefix_ + ':' if (UseCapturedNS_ and self.x_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sx>%s</%sx>%s' % (namespaceprefix_ , self.gds_format_decimal(self.x, input_name='x'), namespaceprefix_ , eol_))
        if self.y is not None:
            namespaceprefix_ = self.y_nsprefix_ + ':' if (UseCapturedNS_ and self.y_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sy>%s</%sy>%s' % (namespaceprefix_ , self.gds_format_decimal(self.y, input_name='y'), namespaceprefix_ , eol_))
        if self.z is not None:
            namespaceprefix_ = self.z_nsprefix_ + ':' if (UseCapturedNS_ and self.z_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sz>%s</%sz>%s' % (namespaceprefix_ , self.gds_format_decimal(self.z, input_name='z'), namespaceprefix_ , eol_))
        if self.ord_nmb is not None:
            namespaceprefix_ = self.ord_nmb_nsprefix_ + ':' if (UseCapturedNS_ and self.ord_nmb_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sord_nmb>%s</%sord_nmb>%s' % (namespaceprefix_ , self.gds_format_integer(self.ord_nmb, input_name='ord_nmb'), namespaceprefix_ , eol_))
        if self.num_geopoint is not None:
            namespaceprefix_ = self.num_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.num_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snum_geopoint>%s</%snum_geopoint>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.num_geopoint), input_name='num_geopoint')), namespaceprefix_ , eol_))
        if self.delta_geopoint is not None:
            namespaceprefix_ = self.delta_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdelta_geopoint>%s</%sdelta_geopoint>%s' % (namespaceprefix_ , self.gds_format_decimal(self.delta_geopoint, input_name='delta_geopoint'), namespaceprefix_ , eol_))
        if self.r is not None:
            namespaceprefix_ = self.r_nsprefix_ + ':' if (UseCapturedNS_ and self.r_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sr>%s</%sr>%s' % (namespaceprefix_ , self.gds_format_decimal(self.r, input_name='r'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'x' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'x')
            fval_ = self.gds_validate_decimal(fval_, node, 'x')
            self.x = fval_
            self.x_nsprefix_ = child_.prefix
        elif nodeName_ == 'y' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'y')
            fval_ = self.gds_validate_decimal(fval_, node, 'y')
            self.y = fval_
            self.y_nsprefix_ = child_.prefix
        elif nodeName_ == 'z' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'z')
            fval_ = self.gds_validate_decimal(fval_, node, 'z')
            self.z = fval_
            self.z_nsprefix_ = child_.prefix
        elif nodeName_ == 'ord_nmb' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'ord_nmb')
            ival_ = self.gds_validate_integer(ival_, node, 'ord_nmb')
            self.ord_nmb = ival_
            self.ord_nmb_nsprefix_ = child_.prefix
        elif nodeName_ == 'num_geopoint':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'num_geopoint')
            value_ = self.gds_validate_string(value_, node, 'num_geopoint')
            self.num_geopoint = value_
            self.num_geopoint_nsprefix_ = child_.prefix
        elif nodeName_ == 'delta_geopoint' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'delta_geopoint')
            fval_ = self.gds_validate_decimal(fval_, node, 'delta_geopoint')
            self.delta_geopoint = fval_
            self.delta_geopoint_nsprefix_ = child_.prefix
        elif nodeName_ == 'r' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'r')
            fval_ = self.gds_validate_decimal(fval_, node, 'r')
            self.r = fval_
            self.r_nsprefix_ = child_.prefix
# end class OrdinateOKSOut


class AdditionalContourLocationOut(GeneratedsSuper):
    """AdditionalContourLocationOut -- Д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    о
    е
    п
    р
    о
    с
    т
    р
    а
    н
    с
    т
    в
    е
    н
    н
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    к
    о
    н
    с
    т
    р
    у
    к
    т
    и
    в
    н
    ы
    х
    э
    л
    е
    м
    е
    н
    т
    о
    в
    limit_dimensions -- П
    р
    е
    д
    е
    л
    ь
    н
    ы
    е
    р
    а
    з
    м
    е
    р
    ы
    sk_id -- С
    и
    с
    т
    е
    м
    а
    к
    о
    о
    р
    д
    и
    н
    а
    т
    intersection_points -- Т
    о
    ч
    к
    и
    п
    е
    р
    е
    с
    е
    ч
    е
    н
    и
    я
    п
    р
    о
    е
    к
    ц
    и
    й
    к
    о
    н
    т
    у
    р
    о
    в
    о
    б
    ъ
    е
    к
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, limit_dimensions=None, sk_id=None, intersection_points=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.limit_dimensions = limit_dimensions
        self.limit_dimensions_nsprefix_ = None
        self.sk_id = sk_id
        self.sk_id_nsprefix_ = None
        self.intersection_points = intersection_points
        self.intersection_points_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AdditionalContourLocationOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AdditionalContourLocationOut.subclass:
            return AdditionalContourLocationOut.subclass(*args_, **kwargs_)
        else:
            return AdditionalContourLocationOut(*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_limit_dimensions(self):
        return self.limit_dimensions
    def set_limit_dimensions(self, limit_dimensions):
        self.limit_dimensions = limit_dimensions
    def get_sk_id(self):
        return self.sk_id
    def set_sk_id(self, sk_id):
        self.sk_id = sk_id
    def get_intersection_points(self):
        return self.intersection_points
    def set_intersection_points(self, intersection_points):
        self.intersection_points = intersection_points
    def has__content(self):
        if (
            self.limit_dimensions is not None or
            self.sk_id is not None or
            self.intersection_points is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AdditionalContourLocationOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AdditionalContourLocationOut')
        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_ == 'AdditionalContourLocationOut':
            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_='AdditionalContourLocationOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AdditionalContourLocationOut', 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_='AdditionalContourLocationOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AdditionalContourLocationOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.limit_dimensions is not None:
            namespaceprefix_ = self.limit_dimensions_nsprefix_ + ':' if (UseCapturedNS_ and self.limit_dimensions_nsprefix_) else ''
            self.limit_dimensions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='limit_dimensions', pretty_print=pretty_print)
        if self.sk_id is not None:
            namespaceprefix_ = self.sk_id_nsprefix_ + ':' if (UseCapturedNS_ and self.sk_id_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssk_id>%s</%ssk_id>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.sk_id), input_name='sk_id')), namespaceprefix_ , eol_))
        if self.intersection_points is not None:
            namespaceprefix_ = self.intersection_points_nsprefix_ + ':' if (UseCapturedNS_ and self.intersection_points_nsprefix_) else ''
            self.intersection_points.export(outfile, level, namespaceprefix_, namespacedef_='', name_='intersection_points', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'limit_dimensions':
            obj_ = LimitDimensions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.limit_dimensions = obj_
            obj_.original_tagname_ = 'limit_dimensions'
        elif nodeName_ == 'sk_id':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'sk_id')
            value_ = self.gds_validate_string(value_, node, 'sk_id')
            self.sk_id = value_
            self.sk_id_nsprefix_ = child_.prefix
        elif nodeName_ == 'intersection_points':
            obj_ = IntersectionPoints.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.intersection_points = obj_
            obj_.original_tagname_ = 'intersection_points'
# end class AdditionalContourLocationOut


class LimitDimensions(GeneratedsSuper):
    """LimitDimensions -- П
    р
    е
    д
    е
    л
    ь
    н
    ы
    е
    р
    а
    з
    м
    е
    р
    ы
    max_depth -- М
    а
    к
    с
    и
    м
    а
    л
    ь
    н
    а
    я
    г
    л
    у
    б
    и
    н
    а
    max_height -- М
    а
    к
    с
    и
    м
    а
    л
    ь
    н
    а
    я
    в
    ы
    с
    о
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, max_depth=None, max_height=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.max_depth = max_depth
        self.max_depth_nsprefix_ = None
        self.max_height = max_height
        self.max_height_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LimitDimensions)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LimitDimensions.subclass:
            return LimitDimensions.subclass(*args_, **kwargs_)
        else:
            return LimitDimensions(*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_max_depth(self):
        return self.max_depth
    def set_max_depth(self, max_depth):
        self.max_depth = max_depth
    def get_max_height(self):
        return self.max_height
    def set_max_height(self, max_height):
        self.max_height = max_height
    def has__content(self):
        if (
            self.max_depth is not None or
            self.max_height is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LimitDimensions', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LimitDimensions')
        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_ == 'LimitDimensions':
            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_='LimitDimensions')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LimitDimensions', 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_='LimitDimensions'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LimitDimensions', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.max_depth is not None:
            namespaceprefix_ = self.max_depth_nsprefix_ + ':' if (UseCapturedNS_ and self.max_depth_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%smax_depth>%s</%smax_depth>%s' % (namespaceprefix_ , self.gds_format_decimal(self.max_depth, input_name='max_depth'), namespaceprefix_ , eol_))
        if self.max_height is not None:
            namespaceprefix_ = self.max_height_nsprefix_ + ':' if (UseCapturedNS_ and self.max_height_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%smax_height>%s</%smax_height>%s' % (namespaceprefix_ , self.gds_format_decimal(self.max_height, input_name='max_height'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'max_depth' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'max_depth')
            fval_ = self.gds_validate_decimal(fval_, node, 'max_depth')
            self.max_depth = fval_
            self.max_depth_nsprefix_ = child_.prefix
        elif nodeName_ == 'max_height' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'max_height')
            fval_ = self.gds_validate_decimal(fval_, node, 'max_height')
            self.max_height = fval_
            self.max_height_nsprefix_ = child_.prefix
# end class LimitDimensions


class IntersectionPoints(GeneratedsSuper):
    """IntersectionPoints -- Т
    о
    ч
    к
    и
    п
    е
    р
    е
    с
    е
    ч
    е
    н
    и
    я
    п
    р
    о
    е
    к
    ц
    и
    й
    level_contour -- У
    р
    о
    в
    е
    н
    ь
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    (
    т
    и
    п
    к
    о
    н
    т
    у
    р
    а
    )
    intersection_point -- Т
    о
    ч
    к
    а
    п
    е
    р
    е
    с
    е
    ч
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, level_contour=None, intersection_point=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.level_contour = level_contour
        self.level_contour_nsprefix_ = None
        if intersection_point is None:
            self.intersection_point = []
        else:
            self.intersection_point = intersection_point
        self.intersection_point_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IntersectionPoints)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IntersectionPoints.subclass:
            return IntersectionPoints.subclass(*args_, **kwargs_)
        else:
            return IntersectionPoints(*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_level_contour(self):
        return self.level_contour
    def set_level_contour(self, level_contour):
        self.level_contour = level_contour
    def get_intersection_point(self):
        return self.intersection_point
    def set_intersection_point(self, intersection_point):
        self.intersection_point = intersection_point
    def add_intersection_point(self, value):
        self.intersection_point.append(value)
    def insert_intersection_point_at(self, index, value):
        self.intersection_point.insert(index, value)
    def replace_intersection_point_at(self, index, value):
        self.intersection_point[index] = value
    def has__content(self):
        if (
            self.level_contour is not None or
            self.intersection_point
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IntersectionPoints', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IntersectionPoints')
        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_ == 'IntersectionPoints':
            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_='IntersectionPoints')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IntersectionPoints', 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_='IntersectionPoints'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IntersectionPoints', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.level_contour is not None:
            namespaceprefix_ = self.level_contour_nsprefix_ + ':' if (UseCapturedNS_ and self.level_contour_nsprefix_) else ''
            self.level_contour.export(outfile, level, namespaceprefix_, namespacedef_='', name_='level_contour', pretty_print=pretty_print)
        for intersection_point_ in self.intersection_point:
            namespaceprefix_ = self.intersection_point_nsprefix_ + ':' if (UseCapturedNS_ and self.intersection_point_nsprefix_) else ''
            intersection_point_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='intersection_point', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'level_contour':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.level_contour = obj_
            obj_.original_tagname_ = 'level_contour'
        elif nodeName_ == 'intersection_point':
            obj_ = IntersectionPoint.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.intersection_point.append(obj_)
            obj_.original_tagname_ = 'intersection_point'
# end class IntersectionPoints


class IntersectionPoint(GeneratedsSuper):
    """IntersectionPoint -- Т
    о
    ч
    к
    а
    п
    е
    р
    е
    с
    е
    ч
    е
    н
    и
    я
    intersection_ordinate -- О
    п
    и
    с
    а
    н
    и
    е
    т
    о
    ч
    к
    и
    п
    е
    р
    е
    с
    е
    ч
    е
    н
    и
    я
    intersection_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    с
    к
    о
    н
    т
    у
    р
    о
    м
    к
    о
    т
    о
    р
    ы
    х
    п
    е
    р
    е
    с
    е
    к
    а
    е
    т
    с
    я
    к
    о
    н
    т
    у
    р
    д
    а
    н
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, intersection_ordinate=None, intersection_cad_numbers=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.intersection_ordinate = intersection_ordinate
        self.intersection_ordinate_nsprefix_ = None
        self.intersection_cad_numbers = intersection_cad_numbers
        self.intersection_cad_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IntersectionPoint)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IntersectionPoint.subclass:
            return IntersectionPoint.subclass(*args_, **kwargs_)
        else:
            return IntersectionPoint(*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_intersection_ordinate(self):
        return self.intersection_ordinate
    def set_intersection_ordinate(self, intersection_ordinate):
        self.intersection_ordinate = intersection_ordinate
    def get_intersection_cad_numbers(self):
        return self.intersection_cad_numbers
    def set_intersection_cad_numbers(self, intersection_cad_numbers):
        self.intersection_cad_numbers = intersection_cad_numbers
    def has__content(self):
        if (
            self.intersection_ordinate is not None or
            self.intersection_cad_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IntersectionPoint', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IntersectionPoint')
        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_ == 'IntersectionPoint':
            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_='IntersectionPoint')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IntersectionPoint', 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_='IntersectionPoint'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IntersectionPoint', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.intersection_ordinate is not None:
            namespaceprefix_ = self.intersection_ordinate_nsprefix_ + ':' if (UseCapturedNS_ and self.intersection_ordinate_nsprefix_) else ''
            self.intersection_ordinate.export(outfile, level, namespaceprefix_, namespacedef_='', name_='intersection_ordinate', pretty_print=pretty_print)
        if self.intersection_cad_numbers is not None:
            namespaceprefix_ = self.intersection_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.intersection_cad_numbers_nsprefix_) else ''
            self.intersection_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='intersection_cad_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'intersection_ordinate':
            obj_ = IntersectionOrdinate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.intersection_ordinate = obj_
            obj_.original_tagname_ = 'intersection_ordinate'
        elif nodeName_ == 'intersection_cad_numbers':
            obj_ = IntersectionCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.intersection_cad_numbers = obj_
            obj_.original_tagname_ = 'intersection_cad_numbers'
# end class IntersectionPoint


class IntersectionOrdinate(GeneratedsSuper):
    """IntersectionOrdinate -- О
    п
    и
    с
    а
    н
    и
    е
    т
    о
    ч
    к
    и
    п
    е
    р
    е
    с
    е
    ч
    е
    н
    и
    я
    x -- Х
    y -- Y
    num_geopoint -- Н
    о
    м
    е
    р
    т
    о
    ч
    к
    и
    delta_geopoint -- П
    о
    г
    р
    е
    ш
    н
    о
    с
    т
    ь
    depth -- Г
    л
    у
    б
    и
    н
    а
    height -- В
    ы
    с
    о
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, x=None, y=None, num_geopoint=None, delta_geopoint=None, depth=None, height=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.x = x
        self.x_nsprefix_ = None
        self.y = y
        self.y_nsprefix_ = None
        self.num_geopoint = num_geopoint
        self.num_geopoint_nsprefix_ = None
        self.delta_geopoint = delta_geopoint
        self.delta_geopoint_nsprefix_ = None
        self.depth = depth
        self.depth_nsprefix_ = None
        self.height = height
        self.height_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IntersectionOrdinate)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IntersectionOrdinate.subclass:
            return IntersectionOrdinate.subclass(*args_, **kwargs_)
        else:
            return IntersectionOrdinate(*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_x(self):
        return self.x
    def set_x(self, x):
        self.x = x
    def get_y(self):
        return self.y
    def set_y(self, y):
        self.y = y
    def get_num_geopoint(self):
        return self.num_geopoint
    def set_num_geopoint(self, num_geopoint):
        self.num_geopoint = num_geopoint
    def get_delta_geopoint(self):
        return self.delta_geopoint
    def set_delta_geopoint(self, delta_geopoint):
        self.delta_geopoint = delta_geopoint
    def get_depth(self):
        return self.depth
    def set_depth(self, depth):
        self.depth = depth
    def get_height(self):
        return self.height
    def set_height(self, height):
        self.height = height
    def has__content(self):
        if (
            self.x is not None or
            self.y is not None or
            self.num_geopoint is not None or
            self.delta_geopoint is not None or
            self.depth is not None or
            self.height is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IntersectionOrdinate', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IntersectionOrdinate')
        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_ == 'IntersectionOrdinate':
            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_='IntersectionOrdinate')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IntersectionOrdinate', 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_='IntersectionOrdinate'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IntersectionOrdinate', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.x is not None:
            namespaceprefix_ = self.x_nsprefix_ + ':' if (UseCapturedNS_ and self.x_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sx>%s</%sx>%s' % (namespaceprefix_ , self.gds_format_decimal(self.x, input_name='x'), namespaceprefix_ , eol_))
        if self.y is not None:
            namespaceprefix_ = self.y_nsprefix_ + ':' if (UseCapturedNS_ and self.y_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sy>%s</%sy>%s' % (namespaceprefix_ , self.gds_format_decimal(self.y, input_name='y'), namespaceprefix_ , eol_))
        if self.num_geopoint is not None:
            namespaceprefix_ = self.num_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.num_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snum_geopoint>%s</%snum_geopoint>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.num_geopoint), input_name='num_geopoint')), namespaceprefix_ , eol_))
        if self.delta_geopoint is not None:
            namespaceprefix_ = self.delta_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdelta_geopoint>%s</%sdelta_geopoint>%s' % (namespaceprefix_ , self.gds_format_decimal(self.delta_geopoint, input_name='delta_geopoint'), namespaceprefix_ , eol_))
        if self.depth is not None:
            namespaceprefix_ = self.depth_nsprefix_ + ':' if (UseCapturedNS_ and self.depth_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdepth>%s</%sdepth>%s' % (namespaceprefix_ , self.gds_format_decimal(self.depth, input_name='depth'), namespaceprefix_ , eol_))
        if self.height is not None:
            namespaceprefix_ = self.height_nsprefix_ + ':' if (UseCapturedNS_ and self.height_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sheight>%s</%sheight>%s' % (namespaceprefix_ , self.gds_format_decimal(self.height, input_name='height'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'x' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'x')
            fval_ = self.gds_validate_decimal(fval_, node, 'x')
            self.x = fval_
            self.x_nsprefix_ = child_.prefix
        elif nodeName_ == 'y' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'y')
            fval_ = self.gds_validate_decimal(fval_, node, 'y')
            self.y = fval_
            self.y_nsprefix_ = child_.prefix
        elif nodeName_ == 'num_geopoint':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'num_geopoint')
            value_ = self.gds_validate_string(value_, node, 'num_geopoint')
            self.num_geopoint = value_
            self.num_geopoint_nsprefix_ = child_.prefix
        elif nodeName_ == 'delta_geopoint' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'delta_geopoint')
            fval_ = self.gds_validate_decimal(fval_, node, 'delta_geopoint')
            self.delta_geopoint = fval_
            self.delta_geopoint_nsprefix_ = child_.prefix
        elif nodeName_ == 'depth' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'depth')
            fval_ = self.gds_validate_decimal(fval_, node, 'depth')
            self.depth = fval_
            self.depth_nsprefix_ = child_.prefix
        elif nodeName_ == 'height' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'height')
            fval_ = self.gds_validate_decimal(fval_, node, 'height')
            self.height = fval_
            self.height_nsprefix_ = child_.prefix
# end class IntersectionOrdinate


class IntersectionCadNumbers(GeneratedsSuper):
    """IntersectionCadNumbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    о
    б
    ъ
    е
    к
    т
    о
    в
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    с
    к
    о
    н
    т
    у
    р
    о
    м
    к
    о
    т
    о
    р
    ы
    х
    п
    е
    р
    е
    с
    е
    к
    а
    е
    т
    с
    я
    к
    о
    н
    т
    у
    р
    д
    а
    н
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    intersection_cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    ,
    с
    к
    о
    н
    т
    у
    р
    о
    м
    к
    о
    т
    о
    р
    о
    г
    о
    п
    е
    р
    е
    с
    е
    к
    а
    е
    т
    с
    я
    к
    о
    н
    т
    у
    р
    д
    а
    н
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, intersection_cad_number=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 intersection_cad_number is None:
            self.intersection_cad_number = []
        else:
            self.intersection_cad_number = intersection_cad_number
        self.intersection_cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IntersectionCadNumbers)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IntersectionCadNumbers.subclass:
            return IntersectionCadNumbers.subclass(*args_, **kwargs_)
        else:
            return IntersectionCadNumbers(*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_intersection_cad_number(self):
        return self.intersection_cad_number
    def set_intersection_cad_number(self, intersection_cad_number):
        self.intersection_cad_number = intersection_cad_number
    def add_intersection_cad_number(self, value):
        self.intersection_cad_number.append(value)
    def insert_intersection_cad_number_at(self, index, value):
        self.intersection_cad_number.insert(index, value)
    def replace_intersection_cad_number_at(self, index, value):
        self.intersection_cad_number[index] = value
    def has__content(self):
        if (
            self.intersection_cad_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IntersectionCadNumbers', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IntersectionCadNumbers')
        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_ == 'IntersectionCadNumbers':
            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_='IntersectionCadNumbers')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IntersectionCadNumbers', 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_='IntersectionCadNumbers'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IntersectionCadNumbers', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for intersection_cad_number_ in self.intersection_cad_number:
            namespaceprefix_ = self.intersection_cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.intersection_cad_number_nsprefix_) else ''
            intersection_cad_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='intersection_cad_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'intersection_cad_number':
            obj_ = CadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.intersection_cad_number.append(obj_)
            obj_.original_tagname_ = 'intersection_cad_number'
# end class IntersectionCadNumbers


class Level(GeneratedsSuper):
    """Level -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    (
    У
    р
    о
    в
    е
    н
    ь
    (
    Э
    т
    а
    ж
    ))
    floor -- Н
    о
    м
    е
    р
    э
    т
    а
    ж
    а
    plans -- П
    л
    а
    н
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, floor=None, plans=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.floor = floor
        self.floor_nsprefix_ = None
        self.plans = plans
        self.plans_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Level)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Level.subclass:
            return Level.subclass(*args_, **kwargs_)
        else:
            return Level(*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_floor(self):
        return self.floor
    def set_floor(self, floor):
        self.floor = floor
    def get_plans(self):
        return self.plans
    def set_plans(self, plans):
        self.plans = plans
    def has__content(self):
        if (
            self.floor is not None or
            self.plans is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Level', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Level')
        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_ == 'Level':
            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_='Level')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Level', 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_='Level'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Level', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.floor is not None:
            namespaceprefix_ = self.floor_nsprefix_ + ':' if (UseCapturedNS_ and self.floor_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfloor>%s</%sfloor>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.floor), input_name='floor')), namespaceprefix_ , eol_))
        if self.plans is not None:
            namespaceprefix_ = self.plans_nsprefix_ + ':' if (UseCapturedNS_ and self.plans_nsprefix_) else ''
            self.plans.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plans', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'floor':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'floor')
            value_ = self.gds_validate_string(value_, node, 'floor')
            self.floor = value_
            self.floor_nsprefix_ = child_.prefix
        elif nodeName_ == 'plans':
            obj_ = plansType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.plans = obj_
            obj_.original_tagname_ = 'plans'
# end class Level


class LevelAll(GeneratedsSuper):
    """LevelAll -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    (
    У
    р
    о
    в
    е
    н
    ь
    (
    Э
    т
    а
    ж
    ))
    floor -- Н
    о
    м
    е
    р
    э
    т
    а
    ж
    а
    floor_type -- Т
    и
    п
    э
    т
    а
    ж
    а
    plan_number -- Н
    о
    м
    е
    р
    н
    а
    п
    о
    э
    т
    а
    ж
    н
    о
    м
    п
    л
    а
    н
    е
    description -- О
    п
    и
    с
    а
    н
    и
    е
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    plans -- П
    л
    а
    н
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, floor=None, floor_type=None, plan_number=None, description=None, plans=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.floor = floor
        self.floor_nsprefix_ = None
        self.floor_type = floor_type
        self.floor_type_nsprefix_ = None
        self.plan_number = plan_number
        self.plan_number_nsprefix_ = None
        self.description = description
        self.validate_MultiLiner(self.description)
        self.description_nsprefix_ = None
        self.plans = plans
        self.plans_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LevelAll)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LevelAll.subclass:
            return LevelAll.subclass(*args_, **kwargs_)
        else:
            return LevelAll(*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_floor(self):
        return self.floor
    def set_floor(self, floor):
        self.floor = floor
    def get_floor_type(self):
        return self.floor_type
    def set_floor_type(self, floor_type):
        self.floor_type = floor_type
    def get_plan_number(self):
        return self.plan_number
    def set_plan_number(self, plan_number):
        self.plan_number = plan_number
    def get_description(self):
        return self.description
    def set_description(self, description):
        self.description = description
    def get_plans(self):
        return self.plans
    def set_plans(self, plans):
        self.plans = plans
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.floor is not None or
            self.floor_type is not None or
            self.plan_number is not None or
            self.description is not None or
            self.plans is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LevelAll', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LevelAll')
        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_ == 'LevelAll':
            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_='LevelAll')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LevelAll', 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_='LevelAll'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LevelAll', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.floor is not None:
            namespaceprefix_ = self.floor_nsprefix_ + ':' if (UseCapturedNS_ and self.floor_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfloor>%s</%sfloor>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.floor), input_name='floor')), namespaceprefix_ , eol_))
        if self.floor_type is not None:
            namespaceprefix_ = self.floor_type_nsprefix_ + ':' if (UseCapturedNS_ and self.floor_type_nsprefix_) else ''
            self.floor_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='floor_type', pretty_print=pretty_print)
        if self.plan_number is not None:
            namespaceprefix_ = self.plan_number_nsprefix_ + ':' if (UseCapturedNS_ and self.plan_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%splan_number>%s</%splan_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.plan_number), input_name='plan_number')), 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.plans is not None:
            namespaceprefix_ = self.plans_nsprefix_ + ':' if (UseCapturedNS_ and self.plans_nsprefix_) else ''
            self.plans.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plans', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'floor':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'floor')
            value_ = self.gds_validate_string(value_, node, 'floor')
            self.floor = value_
            self.floor_nsprefix_ = child_.prefix
        elif nodeName_ == 'floor_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.floor_type = obj_
            obj_.original_tagname_ = 'floor_type'
        elif nodeName_ == 'plan_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'plan_number')
            value_ = self.gds_validate_string(value_, node, 'plan_number')
            self.plan_number = value_
            self.plan_number_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
            # validate type MultiLiner
            self.validate_MultiLiner(self.description)
        elif nodeName_ == 'plans':
            obj_ = Plans.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.plans = obj_
            obj_.original_tagname_ = 'plans'
# end class LevelAll


class Plans(GeneratedsSuper):
    """Plans -- П
    л
    а
    н
    ы
    plan -- П
    л
    а
    н
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, plan=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 plan is None:
            self.plan = []
        else:
            self.plan = plan
        self.plan_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Plans)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Plans.subclass:
            return Plans.subclass(*args_, **kwargs_)
        else:
            return Plans(*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_plan(self):
        return self.plan
    def set_plan(self, plan):
        self.plan = plan
    def add_plan(self, value):
        self.plan.append(value)
    def insert_plan_at(self, index, value):
        self.plan.insert(index, value)
    def replace_plan_at(self, index, value):
        self.plan[index] = value
    def has__content(self):
        if (
            self.plan
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Plans', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Plans')
        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_ == 'Plans':
            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_='Plans')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Plans', 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_='Plans'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Plans', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for plan_ in self.plan:
            namespaceprefix_ = self.plan_nsprefix_ + ':' if (UseCapturedNS_ and self.plan_nsprefix_) else ''
            plan_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plan', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'plan':
            obj_ = Plan.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.plan.append(obj_)
            obj_.original_tagname_ = 'plan'
# end class Plans


class Plan(GeneratedsSuper):
    """Plan -- П
    л
    а
    н
    file_link -- С
    с
    ы
    л
    к
    а
    н
    а
    ф
    а
    й
    л
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, file_link=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.file_link = file_link
        self.file_link_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Plan)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Plan.subclass:
            return Plan.subclass(*args_, **kwargs_)
        else:
            return Plan(*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_file_link(self):
        return self.file_link
    def set_file_link(self, file_link):
        self.file_link = file_link
    def has__content(self):
        if (
            self.file_link is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Plan', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Plan')
        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_ == 'Plan':
            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_='Plan')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Plan', 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_='Plan'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Plan', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.file_link is not None:
            namespaceprefix_ = self.file_link_nsprefix_ + ':' if (UseCapturedNS_ and self.file_link_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfile_link>%s</%sfile_link>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.file_link), input_name='file_link')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'file_link':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'file_link')
            value_ = self.gds_validate_string(value_, node, 'file_link')
            self.file_link = value_
            self.file_link_nsprefix_ = child_.prefix
# end class Plan


class LocationInBuild(GeneratedsSuper):
    """LocationInBuild -- Р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    п
    р
    е
    д
    е
    л
    а
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    )
    level -- Р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    п
    р
    е
    д
    е
    л
    а
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    э
    т
    а
    ж
    а
    ,
    ч
    а
    с
    т
    и
    э
    т
    а
    ж
    а
    ,
    н
    е
    с
    к
    о
    л
    ь
    к
    и
    х
    э
    т
    а
    ж
    е
    й
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, level=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 level is None:
            self.level = []
        else:
            self.level = level
        self.level_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LocationInBuild)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LocationInBuild.subclass:
            return LocationInBuild.subclass(*args_, **kwargs_)
        else:
            return LocationInBuild(*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_level(self):
        return self.level
    def set_level(self, level):
        self.level = level
    def add_level(self, value):
        self.level.append(value)
    def insert_level_at(self, index, value):
        self.level.insert(index, value)
    def replace_level_at(self, index, value):
        self.level[index] = value
    def has__content(self):
        if (
            self.level
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationInBuild', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LocationInBuild')
        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_ == 'LocationInBuild':
            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_='LocationInBuild')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LocationInBuild', 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_='LocationInBuild'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationInBuild', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for level_ in self.level:
            namespaceprefix_ = self.level_nsprefix_ + ':' if (UseCapturedNS_ and self.level_nsprefix_) else ''
            level_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='level', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'level':
            obj_ = LevelAll.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.level.append(obj_)
            obj_.original_tagname_ = 'level'
# end class LocationInBuild


class RoomLocationInBuild(GeneratedsSuper):
    """RoomLocationInBuild -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    )
    room_record -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, room_record=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 room_record is None:
            self.room_record = []
        else:
            self.room_record = room_record
        self.room_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomLocationInBuild)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomLocationInBuild.subclass:
            return RoomLocationInBuild.subclass(*args_, **kwargs_)
        else:
            return RoomLocationInBuild(*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_room_record(self):
        return self.room_record
    def set_room_record(self, room_record):
        self.room_record = room_record
    def add_room_record(self, value):
        self.room_record.append(value)
    def insert_room_record_at(self, index, value):
        self.room_record.insert(index, value)
    def replace_room_record_at(self, index, value):
        self.room_record[index] = value
    def has__content(self):
        if (
            self.room_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomLocationInBuild', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomLocationInBuild')
        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_ == 'RoomLocationInBuild':
            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_='RoomLocationInBuild')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomLocationInBuild', 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_='RoomLocationInBuild'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomLocationInBuild', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for room_record_ in self.room_record:
            namespaceprefix_ = self.room_record_nsprefix_ + ':' if (UseCapturedNS_ and self.room_record_nsprefix_) else ''
            room_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'room_record':
            obj_ = RoomLocationInBuildPlans.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_record.append(obj_)
            obj_.original_tagname_ = 'room_record'
# end class RoomLocationInBuild


class RoomLocationInBuildPlans(GeneratedsSuper):
    """RoomLocationInBuildPlans -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    )
    location_in_build -- Р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    п
    р
    е
    д
    е
    л
    а
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, location_in_build=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.object = object
        self.object_nsprefix_ = None
        self.location_in_build = location_in_build
        self.location_in_build_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomLocationInBuildPlans)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomLocationInBuildPlans.subclass:
            return RoomLocationInBuildPlans.subclass(*args_, **kwargs_)
        else:
            return RoomLocationInBuildPlans(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_location_in_build(self):
        return self.location_in_build
    def set_location_in_build(self, location_in_build):
        self.location_in_build = location_in_build
    def has__content(self):
        if (
            self.object is not None or
            self.location_in_build is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomLocationInBuildPlans', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomLocationInBuildPlans')
        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_ == 'RoomLocationInBuildPlans':
            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_='RoomLocationInBuildPlans')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomLocationInBuildPlans', 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_='RoomLocationInBuildPlans'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomLocationInBuildPlans', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.location_in_build is not None:
            namespaceprefix_ = self.location_in_build_nsprefix_ + ':' if (UseCapturedNS_ and self.location_in_build_nsprefix_) else ''
            self.location_in_build.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location_in_build', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectCadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'location_in_build':
            obj_ = LocationInBuild.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.location_in_build = obj_
            obj_.original_tagname_ = 'location_in_build'
# end class RoomLocationInBuildPlans


class CarParkingSpaceLocationInBuild(GeneratedsSuper):
    """CarParkingSpaceLocationInBuild -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    )
    car_parking_space_record -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, car_parking_space_record=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 car_parking_space_record is None:
            self.car_parking_space_record = []
        else:
            self.car_parking_space_record = car_parking_space_record
        self.car_parking_space_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CarParkingSpaceLocationInBuild)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CarParkingSpaceLocationInBuild.subclass:
            return CarParkingSpaceLocationInBuild.subclass(*args_, **kwargs_)
        else:
            return CarParkingSpaceLocationInBuild(*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_car_parking_space_record(self):
        return self.car_parking_space_record
    def set_car_parking_space_record(self, car_parking_space_record):
        self.car_parking_space_record = car_parking_space_record
    def add_car_parking_space_record(self, value):
        self.car_parking_space_record.append(value)
    def insert_car_parking_space_record_at(self, index, value):
        self.car_parking_space_record.insert(index, value)
    def replace_car_parking_space_record_at(self, index, value):
        self.car_parking_space_record[index] = value
    def has__content(self):
        if (
            self.car_parking_space_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CarParkingSpaceLocationInBuild', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CarParkingSpaceLocationInBuild')
        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_ == 'CarParkingSpaceLocationInBuild':
            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_='CarParkingSpaceLocationInBuild')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CarParkingSpaceLocationInBuild', 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_='CarParkingSpaceLocationInBuild'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CarParkingSpaceLocationInBuild', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for car_parking_space_record_ in self.car_parking_space_record:
            namespaceprefix_ = self.car_parking_space_record_nsprefix_ + ':' if (UseCapturedNS_ and self.car_parking_space_record_nsprefix_) else ''
            car_parking_space_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='car_parking_space_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'car_parking_space_record':
            obj_ = CarParkingSpaceLocationInBuildPlans.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.car_parking_space_record.append(obj_)
            obj_.original_tagname_ = 'car_parking_space_record'
# end class CarParkingSpaceLocationInBuild


class CarParkingSpaceLocationInBuildPlans(GeneratedsSuper):
    """CarParkingSpaceLocationInBuildPlans -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    о
    г
    о
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    )
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    )
    location_in_build -- Р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    п
    р
    е
    д
    е
    л
    а
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, location_in_build=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.object = object
        self.object_nsprefix_ = None
        self.location_in_build = location_in_build
        self.location_in_build_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CarParkingSpaceLocationInBuildPlans)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CarParkingSpaceLocationInBuildPlans.subclass:
            return CarParkingSpaceLocationInBuildPlans.subclass(*args_, **kwargs_)
        else:
            return CarParkingSpaceLocationInBuildPlans(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_location_in_build(self):
        return self.location_in_build
    def set_location_in_build(self, location_in_build):
        self.location_in_build = location_in_build
    def has__content(self):
        if (
            self.object is not None or
            self.location_in_build is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CarParkingSpaceLocationInBuildPlans', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CarParkingSpaceLocationInBuildPlans')
        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_ == 'CarParkingSpaceLocationInBuildPlans':
            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_='CarParkingSpaceLocationInBuildPlans')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CarParkingSpaceLocationInBuildPlans', 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_='CarParkingSpaceLocationInBuildPlans'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CarParkingSpaceLocationInBuildPlans', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.location_in_build is not None:
            namespaceprefix_ = self.location_in_build_nsprefix_ + ':' if (UseCapturedNS_ and self.location_in_build_nsprefix_) else ''
            self.location_in_build.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location_in_build', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectCadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'location_in_build':
            obj_ = LevelAll.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.location_in_build = obj_
            obj_.original_tagname_ = 'location_in_build'
# end class CarParkingSpaceLocationInBuildPlans


class LocationLevelsContours(GeneratedsSuper):
    """LocationLevelsContours -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    и
    о
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    (levels, contours)
    levels -- Р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    п
    р
    е
    д
    е
    л
    а
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    contours -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, levels=None, contours=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.levels = levels
        self.levels_nsprefix_ = None
        self.contours = contours
        self.contours_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LocationLevelsContours)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LocationLevelsContours.subclass:
            return LocationLevelsContours.subclass(*args_, **kwargs_)
        else:
            return LocationLevelsContours(*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_levels(self):
        return self.levels
    def set_levels(self, levels):
        self.levels = levels
    def get_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def has__content(self):
        if (
            self.levels is not None or
            self.contours is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationLevelsContours', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LocationLevelsContours')
        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_ == 'LocationLevelsContours':
            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_='LocationLevelsContours')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LocationLevelsContours', 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_='LocationLevelsContours'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationLevelsContours', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.levels is not None:
            namespaceprefix_ = self.levels_nsprefix_ + ':' if (UseCapturedNS_ and self.levels_nsprefix_) else ''
            self.levels.export(outfile, level, namespaceprefix_, namespacedef_='', name_='levels', pretty_print=pretty_print)
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'levels':
            obj_ = LocationInBuild.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.levels = obj_
            obj_.original_tagname_ = 'levels'
        elif nodeName_ == 'contours':
            obj_ = ContoursOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
# end class LocationLevelsContours


class LocationInBuildContours(GeneratedsSuper):
    """LocationInBuildContours -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    и
    о
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    (in_build, contours)
    in_build -- Р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    п
    р
    е
    д
    е
    л
    а
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    contours -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, in_build=None, contours=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.in_build = in_build
        self.in_build_nsprefix_ = None
        self.contours = contours
        self.contours_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LocationInBuildContours)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LocationInBuildContours.subclass:
            return LocationInBuildContours.subclass(*args_, **kwargs_)
        else:
            return LocationInBuildContours(*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_in_build(self):
        return self.in_build
    def set_in_build(self, in_build):
        self.in_build = in_build
    def get_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def has__content(self):
        if (
            self.in_build is not None or
            self.contours is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationInBuildContours', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LocationInBuildContours')
        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_ == 'LocationInBuildContours':
            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_='LocationInBuildContours')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LocationInBuildContours', 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_='LocationInBuildContours'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationInBuildContours', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.in_build is not None:
            namespaceprefix_ = self.in_build_nsprefix_ + ':' if (UseCapturedNS_ and self.in_build_nsprefix_) else ''
            self.in_build.export(outfile, level, namespaceprefix_, namespacedef_='', name_='in_build', pretty_print=pretty_print)
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'in_build':
            obj_ = LocationInBuild.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.in_build = obj_
            obj_.original_tagname_ = 'in_build'
        elif nodeName_ == 'contours':
            obj_ = ContoursOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
# end class LocationInBuildContours


class SpecificLocation(GeneratedsSuper):
    """SpecificLocation -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    specific_mark_distances -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    с
    т
    о
    я
    н
    и
    я
    х
    о
    т
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    ы
    х
    м
    е
    т
    о
    к
    д
    о
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    г
    р
    а
    н
    и
    ц
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    character_point_distances -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    с
    т
    о
    я
    н
    и
    я
    х
    м
    е
    ж
    д
    у
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    м
    и
    т
    о
    ч
    к
    а
    м
    и
    г
    р
    а
    н
    и
    ц
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    specific_mark_location -- С
    в
    е
    д
    е
    н
    и
    я
    о
    к
    о
    о
    р
    д
    и
    н
    а
    т
    а
    х
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    ы
    х
    м
    е
    т
    о
    к
    room_location -- С
    в
    е
    д
    е
    н
    и
    я
    о
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    к
    а
    х
    г
    р
    а
    н
    и
    ц
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    ,
    в
    к
    о
    т
    о
    р
    о
    м
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, specific_mark_distances=None, character_point_distances=None, specific_mark_location=None, room_location=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.specific_mark_distances = specific_mark_distances
        self.specific_mark_distances_nsprefix_ = None
        self.character_point_distances = character_point_distances
        self.character_point_distances_nsprefix_ = None
        self.specific_mark_location = specific_mark_location
        self.specific_mark_location_nsprefix_ = None
        self.room_location = room_location
        self.room_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpecificLocation)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpecificLocation.subclass:
            return SpecificLocation.subclass(*args_, **kwargs_)
        else:
            return SpecificLocation(*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_specific_mark_distances(self):
        return self.specific_mark_distances
    def set_specific_mark_distances(self, specific_mark_distances):
        self.specific_mark_distances = specific_mark_distances
    def get_character_point_distances(self):
        return self.character_point_distances
    def set_character_point_distances(self, character_point_distances):
        self.character_point_distances = character_point_distances
    def get_specific_mark_location(self):
        return self.specific_mark_location
    def set_specific_mark_location(self, specific_mark_location):
        self.specific_mark_location = specific_mark_location
    def get_room_location(self):
        return self.room_location
    def set_room_location(self, room_location):
        self.room_location = room_location
    def has__content(self):
        if (
            self.specific_mark_distances is not None or
            self.character_point_distances is not None or
            self.specific_mark_location is not None or
            self.room_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificLocation', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpecificLocation')
        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_ == 'SpecificLocation':
            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_='SpecificLocation')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpecificLocation', 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_='SpecificLocation'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificLocation', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.specific_mark_distances is not None:
            namespaceprefix_ = self.specific_mark_distances_nsprefix_ + ':' if (UseCapturedNS_ and self.specific_mark_distances_nsprefix_) else ''
            self.specific_mark_distances.export(outfile, level, namespaceprefix_, namespacedef_='', name_='specific_mark_distances', pretty_print=pretty_print)
        if self.character_point_distances is not None:
            namespaceprefix_ = self.character_point_distances_nsprefix_ + ':' if (UseCapturedNS_ and self.character_point_distances_nsprefix_) else ''
            self.character_point_distances.export(outfile, level, namespaceprefix_, namespacedef_='', name_='character_point_distances', pretty_print=pretty_print)
        if self.specific_mark_location is not None:
            namespaceprefix_ = self.specific_mark_location_nsprefix_ + ':' if (UseCapturedNS_ and self.specific_mark_location_nsprefix_) else ''
            self.specific_mark_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='specific_mark_location', pretty_print=pretty_print)
        if self.room_location is not None:
            namespaceprefix_ = self.room_location_nsprefix_ + ':' if (UseCapturedNS_ and self.room_location_nsprefix_) else ''
            self.room_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'specific_mark_distances':
            obj_ = SpecificMarkDistances.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.specific_mark_distances = obj_
            obj_.original_tagname_ = 'specific_mark_distances'
        elif nodeName_ == 'character_point_distances':
            obj_ = CharacterPointDistances.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.character_point_distances = obj_
            obj_.original_tagname_ = 'character_point_distances'
        elif nodeName_ == 'specific_mark_location':
            obj_ = SpecificMarkLocation.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.specific_mark_location = obj_
            obj_.original_tagname_ = 'specific_mark_location'
        elif nodeName_ == 'room_location':
            obj_ = RoomLocation.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_location = obj_
            obj_.original_tagname_ = 'room_location'
# end class SpecificLocation


class SpecificMarkDistances(GeneratedsSuper):
    """SpecificMarkDistances -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    с
    т
    о
    я
    н
    и
    я
    х
    о
    т
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    ы
    х
    м
    е
    т
    о
    к
    д
    о
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    г
    р
    а
    н
    и
    ц
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    specific_mark_distance -- Р
    а
    с
    с
    т
    о
    я
    н
    и
    е
    о
    т
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    о
    й
    м
    е
    т
    к
    и
    д
    о
    х
    а
    р
    а
    к
    т
    е
    р
    н
    о
    й
    т
    о
    ч
    к
    и
    г
    р
    а
    н
    и
    ц
    ы
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, specific_mark_distance=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 specific_mark_distance is None:
            self.specific_mark_distance = []
        else:
            self.specific_mark_distance = specific_mark_distance
        self.specific_mark_distance_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpecificMarkDistances)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpecificMarkDistances.subclass:
            return SpecificMarkDistances.subclass(*args_, **kwargs_)
        else:
            return SpecificMarkDistances(*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_specific_mark_distance(self):
        return self.specific_mark_distance
    def set_specific_mark_distance(self, specific_mark_distance):
        self.specific_mark_distance = specific_mark_distance
    def add_specific_mark_distance(self, value):
        self.specific_mark_distance.append(value)
    def insert_specific_mark_distance_at(self, index, value):
        self.specific_mark_distance.insert(index, value)
    def replace_specific_mark_distance_at(self, index, value):
        self.specific_mark_distance[index] = value
    def has__content(self):
        if (
            self.specific_mark_distance
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificMarkDistances', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpecificMarkDistances')
        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_ == 'SpecificMarkDistances':
            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_='SpecificMarkDistances')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpecificMarkDistances', 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_='SpecificMarkDistances'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificMarkDistances', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for specific_mark_distance_ in self.specific_mark_distance:
            namespaceprefix_ = self.specific_mark_distance_nsprefix_ + ':' if (UseCapturedNS_ and self.specific_mark_distance_nsprefix_) else ''
            specific_mark_distance_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='specific_mark_distance', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'specific_mark_distance':
            obj_ = SpecificMarkDistance.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.specific_mark_distance.append(obj_)
            obj_.original_tagname_ = 'specific_mark_distance'
# end class SpecificMarkDistances


class CharacterPointDistances(GeneratedsSuper):
    """CharacterPointDistances -- С
    в
    е
    д
    е
    н
    и
    я
    о
    р
    а
    с
    с
    т
    о
    я
    н
    и
    я
    х
    м
    е
    ж
    д
    у
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    м
    и
    т
    о
    ч
    к
    а
    м
    и
    г
    р
    а
    н
    и
    ц
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    character_point_distance -- Р
    а
    с
    с
    т
    о
    я
    н
    и
    е
    о
    т
    т
    о
    ч
    к
    и
    д
    о
    т
    о
    ч
    к
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, character_point_distance=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 character_point_distance is None:
            self.character_point_distance = []
        else:
            self.character_point_distance = character_point_distance
        self.character_point_distance_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CharacterPointDistances)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CharacterPointDistances.subclass:
            return CharacterPointDistances.subclass(*args_, **kwargs_)
        else:
            return CharacterPointDistances(*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_character_point_distance(self):
        return self.character_point_distance
    def set_character_point_distance(self, character_point_distance):
        self.character_point_distance = character_point_distance
    def add_character_point_distance(self, value):
        self.character_point_distance.append(value)
    def insert_character_point_distance_at(self, index, value):
        self.character_point_distance.insert(index, value)
    def replace_character_point_distance_at(self, index, value):
        self.character_point_distance[index] = value
    def has__content(self):
        if (
            self.character_point_distance
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CharacterPointDistances', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CharacterPointDistances')
        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_ == 'CharacterPointDistances':
            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_='CharacterPointDistances')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CharacterPointDistances', 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_='CharacterPointDistances'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CharacterPointDistances', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for character_point_distance_ in self.character_point_distance:
            namespaceprefix_ = self.character_point_distance_nsprefix_ + ':' if (UseCapturedNS_ and self.character_point_distance_nsprefix_) else ''
            character_point_distance_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='character_point_distance', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'character_point_distance':
            obj_ = CharacterPointDistance.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.character_point_distance.append(obj_)
            obj_.original_tagname_ = 'character_point_distance'
# end class CharacterPointDistances


class SpecificMarkLocation(GeneratedsSuper):
    """SpecificMarkLocation -- С
    в
    е
    д
    е
    н
    и
    я
    о
    к
    о
    о
    р
    д
    и
    н
    а
    т
    а
    х
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    ы
    х
    м
    е
    т
    о
    к
    sk_id -- С
    и
    с
    т
    е
    м
    а
    к
    о
    о
    р
    д
    и
    н
    а
    т
    specific_marks -- С
    в
    е
    д
    е
    н
    и
    я
    о
    к
    о
    о
    р
    д
    и
    н
    а
    т
    а
    х
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    ы
    х
    м
    е
    т
    о
    к
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, sk_id=None, specific_marks=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.sk_id = sk_id
        self.sk_id_nsprefix_ = None
        self.specific_marks = specific_marks
        self.specific_marks_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpecificMarkLocation)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpecificMarkLocation.subclass:
            return SpecificMarkLocation.subclass(*args_, **kwargs_)
        else:
            return SpecificMarkLocation(*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_sk_id(self):
        return self.sk_id
    def set_sk_id(self, sk_id):
        self.sk_id = sk_id
    def get_specific_marks(self):
        return self.specific_marks
    def set_specific_marks(self, specific_marks):
        self.specific_marks = specific_marks
    def has__content(self):
        if (
            self.sk_id is not None or
            self.specific_marks is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificMarkLocation', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpecificMarkLocation')
        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_ == 'SpecificMarkLocation':
            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_='SpecificMarkLocation')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpecificMarkLocation', 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_='SpecificMarkLocation'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificMarkLocation', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.sk_id is not None:
            namespaceprefix_ = self.sk_id_nsprefix_ + ':' if (UseCapturedNS_ and self.sk_id_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssk_id>%s</%ssk_id>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.sk_id), input_name='sk_id')), namespaceprefix_ , eol_))
        if self.specific_marks is not None:
            namespaceprefix_ = self.specific_marks_nsprefix_ + ':' if (UseCapturedNS_ and self.specific_marks_nsprefix_) else ''
            self.specific_marks.export(outfile, level, namespaceprefix_, namespacedef_='', name_='specific_marks', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'sk_id':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'sk_id')
            value_ = self.gds_validate_string(value_, node, 'sk_id')
            self.sk_id = value_
            self.sk_id_nsprefix_ = child_.prefix
        elif nodeName_ == 'specific_marks':
            obj_ = SpecificMarks.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.specific_marks = obj_
            obj_.original_tagname_ = 'specific_marks'
# end class SpecificMarkLocation


class RoomLocation(GeneratedsSuper):
    """RoomLocation -- С
    в
    е
    д
    е
    н
    и
    я
    о
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    к
    а
    х
    г
    р
    а
    н
    и
    ц
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    ,
    в
    к
    о
    т
    о
    р
    о
    м
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    sk_id -- С
    и
    с
    т
    е
    м
    а
    к
    о
    о
    р
    д
    и
    н
    а
    т
    room_character_points -- С
    в
    е
    д
    е
    н
    и
    я
    о
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    к
    а
    х
    г
    р
    а
    н
    и
    ц
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, sk_id=None, room_character_points=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.sk_id = sk_id
        self.sk_id_nsprefix_ = None
        self.room_character_points = room_character_points
        self.room_character_points_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomLocation)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomLocation.subclass:
            return RoomLocation.subclass(*args_, **kwargs_)
        else:
            return RoomLocation(*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_sk_id(self):
        return self.sk_id
    def set_sk_id(self, sk_id):
        self.sk_id = sk_id
    def get_room_character_points(self):
        return self.room_character_points
    def set_room_character_points(self, room_character_points):
        self.room_character_points = room_character_points
    def has__content(self):
        if (
            self.sk_id is not None or
            self.room_character_points is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomLocation', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomLocation')
        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_ == 'RoomLocation':
            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_='RoomLocation')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomLocation', 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_='RoomLocation'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomLocation', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.sk_id is not None:
            namespaceprefix_ = self.sk_id_nsprefix_ + ':' if (UseCapturedNS_ and self.sk_id_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssk_id>%s</%ssk_id>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.sk_id), input_name='sk_id')), namespaceprefix_ , eol_))
        if self.room_character_points is not None:
            namespaceprefix_ = self.room_character_points_nsprefix_ + ':' if (UseCapturedNS_ and self.room_character_points_nsprefix_) else ''
            self.room_character_points.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_character_points', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'sk_id':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'sk_id')
            value_ = self.gds_validate_string(value_, node, 'sk_id')
            self.sk_id = value_
            self.sk_id_nsprefix_ = child_.prefix
        elif nodeName_ == 'room_character_points':
            obj_ = RoomCharacterPoints.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_character_points = obj_
            obj_.original_tagname_ = 'room_character_points'
# end class RoomLocation


class SpecificMarkDistance(GeneratedsSuper):
    """SpecificMarkDistance -- Р
    а
    с
    с
    т
    о
    я
    н
    и
    е
    о
    т
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    о
    й
    м
    е
    т
    к
    и
    д
    о
    х
    а
    р
    а
    к
    т
    е
    р
    н
    о
    й
    т
    о
    ч
    к
    и
    г
    р
    а
    н
    и
    ц
    ы
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    number_mark -- Н
    о
    м
    е
    р
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    о
    й
    м
    е
    т
    к
    и
    number_point -- Н
    о
    м
    е
    р
    х
    а
    р
    а
    к
    т
    е
    р
    н
    о
    й
    т
    о
    ч
    к
    и
    г
    р
    а
    н
    и
    ц
    ы
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    distance -- Р
    а
    с
    с
    т
    о
    я
    н
    и
    е
    ,
    м
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_mark=None, number_point=None, distance=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.number_mark = number_mark
        self.number_mark_nsprefix_ = None
        self.number_point = number_point
        self.number_point_nsprefix_ = None
        self.distance = distance
        self.validate_PositiveDecimal(self.distance)
        self.distance_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpecificMarkDistance)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpecificMarkDistance.subclass:
            return SpecificMarkDistance.subclass(*args_, **kwargs_)
        else:
            return SpecificMarkDistance(*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_mark(self):
        return self.number_mark
    def set_number_mark(self, number_mark):
        self.number_mark = number_mark
    def get_number_point(self):
        return self.number_point
    def set_number_point(self, number_point):
        self.number_point = number_point
    def get_distance(self):
        return self.distance
    def set_distance(self, distance):
        self.distance = distance
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.number_mark is not None or
            self.number_point is not None or
            self.distance is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificMarkDistance', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpecificMarkDistance')
        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_ == 'SpecificMarkDistance':
            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_='SpecificMarkDistance')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpecificMarkDistance', 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_='SpecificMarkDistance'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificMarkDistance', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_mark is not None:
            namespaceprefix_ = self.number_mark_nsprefix_ + ':' if (UseCapturedNS_ and self.number_mark_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_mark>%s</%snumber_mark>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number_mark), input_name='number_mark')), namespaceprefix_ , eol_))
        if self.number_point is not None:
            namespaceprefix_ = self.number_point_nsprefix_ + ':' if (UseCapturedNS_ and self.number_point_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_point>%s</%snumber_point>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number_point), input_name='number_point')), namespaceprefix_ , eol_))
        if self.distance is not None:
            namespaceprefix_ = self.distance_nsprefix_ + ':' if (UseCapturedNS_ and self.distance_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdistance>%s</%sdistance>%s' % (namespaceprefix_ , self.gds_format_decimal(self.distance, input_name='distance'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_mark':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'number_mark')
            value_ = self.gds_validate_string(value_, node, 'number_mark')
            self.number_mark = value_
            self.number_mark_nsprefix_ = child_.prefix
        elif nodeName_ == 'number_point':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'number_point')
            value_ = self.gds_validate_string(value_, node, 'number_point')
            self.number_point = value_
            self.number_point_nsprefix_ = child_.prefix
        elif nodeName_ == 'distance' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'distance')
            fval_ = self.gds_validate_decimal(fval_, node, 'distance')
            self.distance = fval_
            self.distance_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.distance)
# end class SpecificMarkDistance


class CharacterPointDistance(GeneratedsSuper):
    """CharacterPointDistance -- Р
    а
    с
    с
    т
    о
    я
    н
    и
    е
    о
    т
    т
    о
    ч
    к
    и
    д
    о
    т
    о
    ч
    к
    и
    number_point1 -- Н
    о
    м
    е
    р
    х
    а
    р
    а
    к
    т
    е
    р
    н
    с
    й
    т
    о
    ч
    к
    и
    number_point2 -- Н
    о
    м
    е
    р
    х
    а
    р
    а
    к
    т
    е
    р
    н
    с
    й
    т
    о
    ч
    к
    и
    distance -- Р
    а
    с
    с
    т
    о
    я
    н
    и
    е
    ,
    м
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_point1=None, number_point2=None, distance=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.number_point1 = number_point1
        self.number_point1_nsprefix_ = None
        self.number_point2 = number_point2
        self.number_point2_nsprefix_ = None
        self.distance = distance
        self.validate_PositiveDecimal(self.distance)
        self.distance_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CharacterPointDistance)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CharacterPointDistance.subclass:
            return CharacterPointDistance.subclass(*args_, **kwargs_)
        else:
            return CharacterPointDistance(*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_point1(self):
        return self.number_point1
    def set_number_point1(self, number_point1):
        self.number_point1 = number_point1
    def get_number_point2(self):
        return self.number_point2
    def set_number_point2(self, number_point2):
        self.number_point2 = number_point2
    def get_distance(self):
        return self.distance
    def set_distance(self, distance):
        self.distance = distance
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.number_point1 is not None or
            self.number_point2 is not None or
            self.distance is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CharacterPointDistance', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CharacterPointDistance')
        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_ == 'CharacterPointDistance':
            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_='CharacterPointDistance')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CharacterPointDistance', 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_='CharacterPointDistance'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CharacterPointDistance', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_point1 is not None:
            namespaceprefix_ = self.number_point1_nsprefix_ + ':' if (UseCapturedNS_ and self.number_point1_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_point1>%s</%snumber_point1>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number_point1), input_name='number_point1')), namespaceprefix_ , eol_))
        if self.number_point2 is not None:
            namespaceprefix_ = self.number_point2_nsprefix_ + ':' if (UseCapturedNS_ and self.number_point2_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_point2>%s</%snumber_point2>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number_point2), input_name='number_point2')), namespaceprefix_ , eol_))
        if self.distance is not None:
            namespaceprefix_ = self.distance_nsprefix_ + ':' if (UseCapturedNS_ and self.distance_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdistance>%s</%sdistance>%s' % (namespaceprefix_ , self.gds_format_decimal(self.distance, input_name='distance'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_point1':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'number_point1')
            value_ = self.gds_validate_string(value_, node, 'number_point1')
            self.number_point1 = value_
            self.number_point1_nsprefix_ = child_.prefix
        elif nodeName_ == 'number_point2':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'number_point2')
            value_ = self.gds_validate_string(value_, node, 'number_point2')
            self.number_point2 = value_
            self.number_point2_nsprefix_ = child_.prefix
        elif nodeName_ == 'distance' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'distance')
            fval_ = self.gds_validate_decimal(fval_, node, 'distance')
            self.distance = fval_
            self.distance_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.distance)
# end class CharacterPointDistance


class RoomCharacterPoints(GeneratedsSuper):
    """RoomCharacterPoints -- С
    в
    е
    д
    е
    н
    и
    я
    о
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    к
    а
    х
    г
    р
    а
    н
    и
    ц
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    ,
    в
    к
    о
    т
    о
    р
    о
    м
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    о
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    room_character_point -- Х
    а
    р
    а
    к
    т
    е
    р
    н
    а
    я
    т
    о
    ч
    к
    а
    г
    р
    а
    н
    и
    ц
    ы
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, room_character_point=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 room_character_point is None:
            self.room_character_point = []
        else:
            self.room_character_point = room_character_point
        self.room_character_point_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomCharacterPoints)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomCharacterPoints.subclass:
            return RoomCharacterPoints.subclass(*args_, **kwargs_)
        else:
            return RoomCharacterPoints(*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_room_character_point(self):
        return self.room_character_point
    def set_room_character_point(self, room_character_point):
        self.room_character_point = room_character_point
    def add_room_character_point(self, value):
        self.room_character_point.append(value)
    def insert_room_character_point_at(self, index, value):
        self.room_character_point.insert(index, value)
    def replace_room_character_point_at(self, index, value):
        self.room_character_point[index] = value
    def has__content(self):
        if (
            self.room_character_point
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomCharacterPoints', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomCharacterPoints')
        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_ == 'RoomCharacterPoints':
            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_='RoomCharacterPoints')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomCharacterPoints', 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_='RoomCharacterPoints'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomCharacterPoints', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for room_character_point_ in self.room_character_point:
            namespaceprefix_ = self.room_character_point_nsprefix_ + ':' if (UseCapturedNS_ and self.room_character_point_nsprefix_) else ''
            room_character_point_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_character_point', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'room_character_point':
            obj_ = RoomCharacterPoint.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_character_point.append(obj_)
            obj_.original_tagname_ = 'room_character_point'
# end class RoomCharacterPoints


class RoomCharacterPoint(GeneratedsSuper):
    """RoomCharacterPoint -- Х
    а
    р
    а
    к
    т
    е
    р
    н
    а
    я
    т
    о
    ч
    к
    а
    г
    р
    а
    н
    и
    ц
    ы
    number_point -- Н
    о
    м
    е
    р
    х
    а
    р
    а
    к
    т
    е
    р
    н
    о
    й
    т
    о
    ч
    к
    и
    point_ordinate -- К
    о
    о
    р
    д
    и
    н
    а
    т
    ы
    х
    а
    р
    а
    к
    т
    е
    р
    н
    о
    й
    т
    о
    ч
    к
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_point=None, point_ordinate=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.number_point = number_point
        self.number_point_nsprefix_ = None
        self.point_ordinate = point_ordinate
        self.point_ordinate_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomCharacterPoint)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomCharacterPoint.subclass:
            return RoomCharacterPoint.subclass(*args_, **kwargs_)
        else:
            return RoomCharacterPoint(*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_point(self):
        return self.number_point
    def set_number_point(self, number_point):
        self.number_point = number_point
    def get_point_ordinate(self):
        return self.point_ordinate
    def set_point_ordinate(self, point_ordinate):
        self.point_ordinate = point_ordinate
    def has__content(self):
        if (
            self.number_point is not None or
            self.point_ordinate is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomCharacterPoint', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomCharacterPoint')
        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_ == 'RoomCharacterPoint':
            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_='RoomCharacterPoint')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomCharacterPoint', 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_='RoomCharacterPoint'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomCharacterPoint', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_point is not None:
            namespaceprefix_ = self.number_point_nsprefix_ + ':' if (UseCapturedNS_ and self.number_point_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_point>%s</%snumber_point>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number_point), input_name='number_point')), namespaceprefix_ , eol_))
        if self.point_ordinate is not None:
            namespaceprefix_ = self.point_ordinate_nsprefix_ + ':' if (UseCapturedNS_ and self.point_ordinate_nsprefix_) else ''
            self.point_ordinate.export(outfile, level, namespaceprefix_, namespacedef_='', name_='point_ordinate', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_point':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'number_point')
            value_ = self.gds_validate_string(value_, node, 'number_point')
            self.number_point = value_
            self.number_point_nsprefix_ = child_.prefix
        elif nodeName_ == 'point_ordinate':
            obj_ = MarkOrdinate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.point_ordinate = obj_
            obj_.original_tagname_ = 'point_ordinate'
# end class RoomCharacterPoint


class SpecificMarks(GeneratedsSuper):
    """SpecificMarks -- С
    в
    е
    д
    е
    н
    и
    я
    о
    к
    о
    о
    р
    д
    и
    н
    а
    т
    а
    х
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    ы
    х
    м
    е
    т
    о
    к
    specific_mark -- С
    п
    е
    ц
    и
    а
    л
    ь
    н
    а
    я
    м
    е
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, specific_mark=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 specific_mark is None:
            self.specific_mark = []
        else:
            self.specific_mark = specific_mark
        self.specific_mark_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpecificMarks)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpecificMarks.subclass:
            return SpecificMarks.subclass(*args_, **kwargs_)
        else:
            return SpecificMarks(*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_specific_mark(self):
        return self.specific_mark
    def set_specific_mark(self, specific_mark):
        self.specific_mark = specific_mark
    def add_specific_mark(self, value):
        self.specific_mark.append(value)
    def insert_specific_mark_at(self, index, value):
        self.specific_mark.insert(index, value)
    def replace_specific_mark_at(self, index, value):
        self.specific_mark[index] = value
    def has__content(self):
        if (
            self.specific_mark
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificMarks', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpecificMarks')
        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_ == 'SpecificMarks':
            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_='SpecificMarks')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpecificMarks', 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_='SpecificMarks'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificMarks', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for specific_mark_ in self.specific_mark:
            namespaceprefix_ = self.specific_mark_nsprefix_ + ':' if (UseCapturedNS_ and self.specific_mark_nsprefix_) else ''
            specific_mark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='specific_mark', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'specific_mark':
            obj_ = SpecificMark.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.specific_mark.append(obj_)
            obj_.original_tagname_ = 'specific_mark'
# end class SpecificMarks


class SpecificMark(GeneratedsSuper):
    """SpecificMark -- С
    п
    е
    ц
    и
    а
    л
    ь
    н
    а
    я
    м
    е
    т
    к
    а
    number_mark -- Н
    о
    м
    е
    р
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    о
    й
    м
    е
    т
    к
    и
    mark_ordinate -- К
    о
    о
    р
    д
    и
    н
    а
    т
    ы
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    о
    й
    м
    е
    т
    к
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_mark=None, mark_ordinate=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.number_mark = number_mark
        self.number_mark_nsprefix_ = None
        self.mark_ordinate = mark_ordinate
        self.mark_ordinate_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpecificMark)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpecificMark.subclass:
            return SpecificMark.subclass(*args_, **kwargs_)
        else:
            return SpecificMark(*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_mark(self):
        return self.number_mark
    def set_number_mark(self, number_mark):
        self.number_mark = number_mark
    def get_mark_ordinate(self):
        return self.mark_ordinate
    def set_mark_ordinate(self, mark_ordinate):
        self.mark_ordinate = mark_ordinate
    def has__content(self):
        if (
            self.number_mark is not None or
            self.mark_ordinate is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificMark', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpecificMark')
        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_ == 'SpecificMark':
            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_='SpecificMark')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpecificMark', 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_='SpecificMark'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpecificMark', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_mark is not None:
            namespaceprefix_ = self.number_mark_nsprefix_ + ':' if (UseCapturedNS_ and self.number_mark_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_mark>%s</%snumber_mark>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number_mark), input_name='number_mark')), namespaceprefix_ , eol_))
        if self.mark_ordinate is not None:
            namespaceprefix_ = self.mark_ordinate_nsprefix_ + ':' if (UseCapturedNS_ and self.mark_ordinate_nsprefix_) else ''
            self.mark_ordinate.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mark_ordinate', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_mark':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'number_mark')
            value_ = self.gds_validate_string(value_, node, 'number_mark')
            self.number_mark = value_
            self.number_mark_nsprefix_ = child_.prefix
        elif nodeName_ == 'mark_ordinate':
            obj_ = MarkOrdinate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.mark_ordinate = obj_
            obj_.original_tagname_ = 'mark_ordinate'
# end class SpecificMark


class MarkOrdinate(GeneratedsSuper):
    """MarkOrdinate -- К
    о
    о
    р
    д
    и
    н
    а
    т
    ы
    х
    а
    р
    а
    к
    т
    е
    р
    н
    о
    й
    т
    о
    ч
    к
    и
    x -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    X
    y -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    Y
    delta_geopoint -- С
    р
    е
    д
    н
    я
    я
    к
    в
    а
    д
    р
    а
    т
    и
    ч
    е
    с
    к
    а
    я
    п
    о
    г
    р
    е
    ш
    н
    о
    с
    т
    ь
    о
    п
    р
    е
    д
    е
    л
    е
    н
    и
    я
    к
    о
    о
    р
    д
    и
    н
    а
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, x=None, y=None, delta_geopoint=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.x = x
        self.x_nsprefix_ = None
        self.y = y
        self.y_nsprefix_ = None
        self.delta_geopoint = delta_geopoint
        self.delta_geopoint_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, MarkOrdinate)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if MarkOrdinate.subclass:
            return MarkOrdinate.subclass(*args_, **kwargs_)
        else:
            return MarkOrdinate(*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_x(self):
        return self.x
    def set_x(self, x):
        self.x = x
    def get_y(self):
        return self.y
    def set_y(self, y):
        self.y = y
    def get_delta_geopoint(self):
        return self.delta_geopoint
    def set_delta_geopoint(self, delta_geopoint):
        self.delta_geopoint = delta_geopoint
    def has__content(self):
        if (
            self.x is not None or
            self.y is not None or
            self.delta_geopoint is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MarkOrdinate', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('MarkOrdinate')
        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_ == 'MarkOrdinate':
            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_='MarkOrdinate')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MarkOrdinate', 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_='MarkOrdinate'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MarkOrdinate', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.x is not None:
            namespaceprefix_ = self.x_nsprefix_ + ':' if (UseCapturedNS_ and self.x_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sx>%s</%sx>%s' % (namespaceprefix_ , self.gds_format_decimal(self.x, input_name='x'), namespaceprefix_ , eol_))
        if self.y is not None:
            namespaceprefix_ = self.y_nsprefix_ + ':' if (UseCapturedNS_ and self.y_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sy>%s</%sy>%s' % (namespaceprefix_ , self.gds_format_decimal(self.y, input_name='y'), namespaceprefix_ , eol_))
        if self.delta_geopoint is not None:
            namespaceprefix_ = self.delta_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdelta_geopoint>%s</%sdelta_geopoint>%s' % (namespaceprefix_ , self.gds_format_decimal(self.delta_geopoint, input_name='delta_geopoint'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'x' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'x')
            fval_ = self.gds_validate_decimal(fval_, node, 'x')
            self.x = fval_
            self.x_nsprefix_ = child_.prefix
        elif nodeName_ == 'y' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'y')
            fval_ = self.gds_validate_decimal(fval_, node, 'y')
            self.y = fval_
            self.y_nsprefix_ = child_.prefix
        elif nodeName_ == 'delta_geopoint' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'delta_geopoint')
            fval_ = self.gds_validate_decimal(fval_, node, 'delta_geopoint')
            self.delta_geopoint = fval_
            self.delta_geopoint_nsprefix_ = child_.prefix
# end class MarkOrdinate


class Bobject(GeneratedsSuper):
    """Bobject -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    р
    е
    е
    с
    т
    р
    а
    г
    р
    а
    н
    и
    ц
    reg_numb_border -- Р
    е
    е
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    г
    р
    а
    н
    и
    ц
    ы
    type_boundary -- В
    и
    д
    о
    б
    ъ
    е
    к
    т
    а
    р
    е
    е
    с
    т
    р
    а
    г
    р
    а
    н
    и
    ц
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, reg_numb_border=None, type_boundary=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.reg_numb_border = reg_numb_border
        self.reg_numb_border_nsprefix_ = None
        self.type_boundary = type_boundary
        self.type_boundary_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Bobject)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Bobject.subclass:
            return Bobject.subclass(*args_, **kwargs_)
        else:
            return Bobject(*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_reg_numb_border(self):
        return self.reg_numb_border
    def set_reg_numb_border(self, reg_numb_border):
        self.reg_numb_border = reg_numb_border
    def get_type_boundary(self):
        return self.type_boundary
    def set_type_boundary(self, type_boundary):
        self.type_boundary = type_boundary
    def has__content(self):
        if (
            self.reg_numb_border is not None or
            self.type_boundary is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Bobject', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Bobject')
        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_ == 'Bobject':
            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_='Bobject')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Bobject', 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_='Bobject'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Bobject', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.reg_numb_border is not None:
            namespaceprefix_ = self.reg_numb_border_nsprefix_ + ':' if (UseCapturedNS_ and self.reg_numb_border_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreg_numb_border>%s</%sreg_numb_border>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.reg_numb_border), input_name='reg_numb_border')), namespaceprefix_ , eol_))
        if self.type_boundary is not None:
            namespaceprefix_ = self.type_boundary_nsprefix_ + ':' if (UseCapturedNS_ and self.type_boundary_nsprefix_) else ''
            self.type_boundary.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type_boundary', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'reg_numb_border':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'reg_numb_border')
            value_ = self.gds_validate_string(value_, node, 'reg_numb_border')
            self.reg_numb_border = value_
            self.reg_numb_border_nsprefix_ = child_.prefix
        elif nodeName_ == 'type_boundary':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_boundary = obj_
            obj_.original_tagname_ = 'type_boundary'
# end class Bobject


class BobjectSubjectBoundary(GeneratedsSuper):
    """BobjectSubjectBoundary -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    е
    м
    е
    ж
    д
    у
    с
    у
    б
    ъ
    е
    к
    т
    а
    м
    и
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    b_object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    р
    е
    е
    с
    т
    р
    а
    г
    р
    а
    н
    и
    ц
    neighbour_regions -- С
    м
    е
    ж
    н
    ы
    е
    с
    у
    б
    ъ
    е
    к
    т
    ы
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    description -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    з
    е
    м
    л
    е
    у
    с
    т
    р
    о
    й
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, b_object=None, neighbour_regions=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.b_object = b_object
        self.b_object_nsprefix_ = None
        self.neighbour_regions = neighbour_regions
        self.neighbour_regions_nsprefix_ = None
        self.description = description
        self.validate_MultiLiner(self.description)
        self.description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BobjectSubjectBoundary)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BobjectSubjectBoundary.subclass:
            return BobjectSubjectBoundary.subclass(*args_, **kwargs_)
        else:
            return BobjectSubjectBoundary(*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_b_object(self):
        return self.b_object
    def set_b_object(self, b_object):
        self.b_object = b_object
    def get_neighbour_regions(self):
        return self.neighbour_regions
    def set_neighbour_regions(self, neighbour_regions):
        self.neighbour_regions = neighbour_regions
    def get_description(self):
        return self.description
    def set_description(self, description):
        self.description = description
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.b_object is not None or
            self.neighbour_regions is not None or
            self.description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BobjectSubjectBoundary', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BobjectSubjectBoundary')
        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_ == 'BobjectSubjectBoundary':
            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_='BobjectSubjectBoundary')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BobjectSubjectBoundary', 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_='BobjectSubjectBoundary'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BobjectSubjectBoundary', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.b_object is not None:
            namespaceprefix_ = self.b_object_nsprefix_ + ':' if (UseCapturedNS_ and self.b_object_nsprefix_) else ''
            self.b_object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_object', pretty_print=pretty_print)
        if self.neighbour_regions is not None:
            namespaceprefix_ = self.neighbour_regions_nsprefix_ + ':' if (UseCapturedNS_ and self.neighbour_regions_nsprefix_) else ''
            self.neighbour_regions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='neighbour_regions', pretty_print=pretty_print)
        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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'b_object':
            obj_ = Bobject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_object = obj_
            obj_.original_tagname_ = 'b_object'
        elif nodeName_ == 'neighbour_regions':
            obj_ = NeighbourRegions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.neighbour_regions = obj_
            obj_.original_tagname_ = 'neighbour_regions'
        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
            # validate type MultiLiner
            self.validate_MultiLiner(self.description)
# end class BobjectSubjectBoundary


class NeighbourRegions(GeneratedsSuper):
    """NeighbourRegions -- С
    м
    е
    ж
    н
    ы
    е
    с
    у
    б
    ъ
    е
    к
    т
    ы
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    neighbour_region -- С
    м
    е
    ж
    н
    ы
    й
    с
    у
    б
    ъ
    е
    к
    т
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, neighbour_region=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 neighbour_region is None:
            self.neighbour_region = []
        else:
            self.neighbour_region = neighbour_region
        self.neighbour_region_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, NeighbourRegions)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if NeighbourRegions.subclass:
            return NeighbourRegions.subclass(*args_, **kwargs_)
        else:
            return NeighbourRegions(*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_neighbour_region(self):
        return self.neighbour_region
    def set_neighbour_region(self, neighbour_region):
        self.neighbour_region = neighbour_region
    def add_neighbour_region(self, value):
        self.neighbour_region.append(value)
    def insert_neighbour_region_at(self, index, value):
        self.neighbour_region.insert(index, value)
    def replace_neighbour_region_at(self, index, value):
        self.neighbour_region[index] = value
    def has__content(self):
        if (
            self.neighbour_region
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NeighbourRegions', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('NeighbourRegions')
        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_ == 'NeighbourRegions':
            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_='NeighbourRegions')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NeighbourRegions', 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_='NeighbourRegions'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NeighbourRegions', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for neighbour_region_ in self.neighbour_region:
            namespaceprefix_ = self.neighbour_region_nsprefix_ + ':' if (UseCapturedNS_ and self.neighbour_region_nsprefix_) else ''
            neighbour_region_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='neighbour_region', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'neighbour_region':
            obj_ = NeighbourRegion.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.neighbour_region.append(obj_)
            obj_.original_tagname_ = 'neighbour_region'
# end class NeighbourRegions


class NeighbourRegion(GeneratedsSuper):
    """NeighbourRegion -- С
    м
    е
    ж
    н
    ы
    й
    с
    у
    б
    ъ
    е
    к
    т
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    name_neighbour_region -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    с
    м
    е
    ж
    н
    о
    г
    о
    с
    у
    б
    ъ
    е
    к
    т
    а
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, name_neighbour_region=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.name_neighbour_region = name_neighbour_region
        self.name_neighbour_region_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, NeighbourRegion)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if NeighbourRegion.subclass:
            return NeighbourRegion.subclass(*args_, **kwargs_)
        else:
            return NeighbourRegion(*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_neighbour_region(self):
        return self.name_neighbour_region
    def set_name_neighbour_region(self, name_neighbour_region):
        self.name_neighbour_region = name_neighbour_region
    def has__content(self):
        if (
            self.name_neighbour_region is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NeighbourRegion', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('NeighbourRegion')
        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_ == 'NeighbourRegion':
            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_='NeighbourRegion')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NeighbourRegion', 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_='NeighbourRegion'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NeighbourRegion', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.name_neighbour_region is not None:
            namespaceprefix_ = self.name_neighbour_region_nsprefix_ + ':' if (UseCapturedNS_ and self.name_neighbour_region_nsprefix_) else ''
            self.name_neighbour_region.export(outfile, level, namespaceprefix_, namespacedef_='', name_='name_neighbour_region', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'name_neighbour_region':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.name_neighbour_region = obj_
            obj_.original_tagname_ = 'name_neighbour_region'
# end class NeighbourRegion


class BobjectMunicipalInhabitedBoundary(GeneratedsSuper):
    """BobjectMunicipalInhabitedBoundary -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    е
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    о
    г
    о
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    я
    ,
    н
    а
    с
    е
    л
    е
    н
    н
    о
    г
    о
    п
    у
    н
    к
    т
    а
    b_object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    р
    е
    е
    с
    т
    р
    а
    г
    р
    а
    н
    и
    ц
    description -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    з
    е
    м
    л
    е
    у
    с
    т
    р
    о
    й
    с
    т
    в
    а
    address -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    з
    е
    м
    л
    е
    у
    с
    т
    р
    о
    й
    с
    т
    в
    а
    (
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, b_object=None, description=None, address=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.b_object = b_object
        self.b_object_nsprefix_ = None
        self.description = description
        self.validate_MultiLiner(self.description)
        self.description_nsprefix_ = None
        self.address = address
        self.address_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BobjectMunicipalInhabitedBoundary)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BobjectMunicipalInhabitedBoundary.subclass:
            return BobjectMunicipalInhabitedBoundary.subclass(*args_, **kwargs_)
        else:
            return BobjectMunicipalInhabitedBoundary(*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_b_object(self):
        return self.b_object
    def set_b_object(self, b_object):
        self.b_object = b_object
    def get_description(self):
        return self.description
    def set_description(self, description):
        self.description = description
    def get_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.b_object is not None or
            self.description is not None or
            self.address is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BobjectMunicipalInhabitedBoundary', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BobjectMunicipalInhabitedBoundary')
        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_ == 'BobjectMunicipalInhabitedBoundary':
            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_='BobjectMunicipalInhabitedBoundary')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BobjectMunicipalInhabitedBoundary', 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_='BobjectMunicipalInhabitedBoundary'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BobjectMunicipalInhabitedBoundary', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.b_object is not None:
            namespaceprefix_ = self.b_object_nsprefix_ + ':' if (UseCapturedNS_ and self.b_object_nsprefix_) else ''
            self.b_object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_object', pretty_print=pretty_print)
        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.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'b_object':
            obj_ = Bobject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_object = obj_
            obj_.original_tagname_ = 'b_object'
        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
            # validate type MultiLiner
            self.validate_MultiLiner(self.description)
        elif nodeName_ == 'address':
            obj_ = Name.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
# end class BobjectMunicipalInhabitedBoundary


class BobjectCoastline(GeneratedsSuper):
    """BobjectCoastline -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    е
    р
    е
    г
    о
    в
    о
    й
    л
    и
    н
    и
    и
    (
    г
    р
    а
    н
    и
    ц
    е
    в
    о
    д
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    )
    b_object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    р
    е
    е
    с
    т
    р
    а
    г
    р
    а
    н
    и
    ц
    water -- В
    о
    д
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    (
    в
    и
    д
    ,
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, b_object=None, water=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.b_object = b_object
        self.b_object_nsprefix_ = None
        self.water = water
        self.water_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BobjectCoastline)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BobjectCoastline.subclass:
            return BobjectCoastline.subclass(*args_, **kwargs_)
        else:
            return BobjectCoastline(*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_b_object(self):
        return self.b_object
    def set_b_object(self, b_object):
        self.b_object = b_object
    def get_water(self):
        return self.water
    def set_water(self, water):
        self.water = water
    def has__content(self):
        if (
            self.b_object is not None or
            self.water is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BobjectCoastline', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BobjectCoastline')
        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_ == 'BobjectCoastline':
            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_='BobjectCoastline')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BobjectCoastline', 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_='BobjectCoastline'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BobjectCoastline', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.b_object is not None:
            namespaceprefix_ = self.b_object_nsprefix_ + ':' if (UseCapturedNS_ and self.b_object_nsprefix_) else ''
            self.b_object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_object', pretty_print=pretty_print)
        if self.water is not None:
            namespaceprefix_ = self.water_nsprefix_ + ':' if (UseCapturedNS_ and self.water_nsprefix_) else ''
            self.water.export(outfile, level, namespaceprefix_, namespacedef_='', name_='water', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'b_object':
            obj_ = Bobject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_object = obj_
            obj_.original_tagname_ = 'b_object'
        elif nodeName_ == 'water':
            obj_ = Water.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.water = obj_
            obj_.original_tagname_ = 'water'
# end class BobjectCoastline


class BobjectZonesAndTerritories(GeneratedsSuper):
    """BobjectZonesAndTerritories -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    з
    о
    н
    е
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    ,
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    е
    ,
    л
    е
    с
    о
    п
    а
    р
    к
    е
    ,
    о
    х
    о
    т
    н
    и
    ч
    ь
    е
    м
    у
    г
    о
    д
    ь
    е
    b_object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    р
    е
    е
    с
    т
    р
    а
    г
    р
    а
    н
    и
    ц
    description -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    з
    е
    м
    л
    е
    у
    с
    т
    р
    о
    й
    с
    т
    в
    а
    name_by_doc -- В
    и
    д
    и
    л
    и
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    п
    о
    д
    о
    к
    у
    м
    е
    н
    т
    у
    type_zone -- Т
    и
    п
    з
    о
    н
    ы
    (
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    )
    number -- Н
    о
    м
    е
    р
    index -- И
    н
    д
    е
    к
    с
    other -- И
    н
    ы
    е
    и
    д
    е
    н
    т
    и
    ф
    и
    ц
    и
    р
    у
    ю
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, b_object=None, description=None, name_by_doc=None, type_zone=None, number=None, index=None, other=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.b_object = b_object
        self.b_object_nsprefix_ = None
        self.description = description
        self.validate_MultiLiner(self.description)
        self.description_nsprefix_ = None
        self.name_by_doc = name_by_doc
        self.validate_MultiLiner(self.name_by_doc)
        self.name_by_doc_nsprefix_ = None
        self.type_zone = type_zone
        self.type_zone_nsprefix_ = None
        self.number = number
        self.number_nsprefix_ = None
        self.index = index
        self.index_nsprefix_ = None
        self.other = other
        self.other_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BobjectZonesAndTerritories)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BobjectZonesAndTerritories.subclass:
            return BobjectZonesAndTerritories.subclass(*args_, **kwargs_)
        else:
            return BobjectZonesAndTerritories(*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_b_object(self):
        return self.b_object
    def set_b_object(self, b_object):
        self.b_object = b_object
    def get_description(self):
        return self.description
    def set_description(self, description):
        self.description = description
    def get_name_by_doc(self):
        return self.name_by_doc
    def set_name_by_doc(self, name_by_doc):
        self.name_by_doc = name_by_doc
    def get_type_zone(self):
        return self.type_zone
    def set_type_zone(self, type_zone):
        self.type_zone = type_zone
    def get_number(self):
        return self.number
    def set_number(self, number):
        self.number = number
    def get_index(self):
        return self.index
    def set_index(self, index):
        self.index = index
    def get_other(self):
        return self.other
    def set_other(self, other):
        self.other = other
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.b_object is not None or
            self.description is not None or
            self.name_by_doc is not None or
            self.type_zone is not None or
            self.number is not None or
            self.index is not None or
            self.other is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BobjectZonesAndTerritories', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BobjectZonesAndTerritories')
        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_ == 'BobjectZonesAndTerritories':
            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_='BobjectZonesAndTerritories')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BobjectZonesAndTerritories', 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_='BobjectZonesAndTerritories'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BobjectZonesAndTerritories', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.b_object is not None:
            namespaceprefix_ = self.b_object_nsprefix_ + ':' if (UseCapturedNS_ and self.b_object_nsprefix_) else ''
            self.b_object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_object', pretty_print=pretty_print)
        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.name_by_doc is not None:
            namespaceprefix_ = self.name_by_doc_nsprefix_ + ':' if (UseCapturedNS_ and self.name_by_doc_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_by_doc>%s</%sname_by_doc>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_by_doc), input_name='name_by_doc')), namespaceprefix_ , eol_))
        if self.type_zone is not None:
            namespaceprefix_ = self.type_zone_nsprefix_ + ':' if (UseCapturedNS_ and self.type_zone_nsprefix_) else ''
            self.type_zone.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type_zone', pretty_print=pretty_print)
        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.index is not None:
            namespaceprefix_ = self.index_nsprefix_ + ':' if (UseCapturedNS_ and self.index_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sindex>%s</%sindex>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.index), input_name='index')), namespaceprefix_ , eol_))
        if self.other is not None:
            namespaceprefix_ = self.other_nsprefix_ + ':' if (UseCapturedNS_ and self.other_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sother>%s</%sother>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.other), input_name='other')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'b_object':
            obj_ = Bobject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_object = obj_
            obj_.original_tagname_ = 'b_object'
        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
            # validate type MultiLiner
            self.validate_MultiLiner(self.description)
        elif nodeName_ == 'name_by_doc':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_by_doc')
            value_ = self.gds_validate_string(value_, node, 'name_by_doc')
            self.name_by_doc = value_
            self.name_by_doc_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.name_by_doc)
        elif nodeName_ == 'type_zone':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_zone = obj_
            obj_.original_tagname_ = 'type_zone'
        elif 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_ == 'index':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'index')
            value_ = self.gds_validate_string(value_, node, 'index')
            self.index = value_
            self.index_nsprefix_ = child_.prefix
        elif nodeName_ == 'other':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'other')
            value_ = self.gds_validate_string(value_, node, 'other')
            self.other = value_
            self.other_nsprefix_ = child_.prefix
# end class BobjectZonesAndTerritories


class BobjectSurveyingProject(GeneratedsSuper):
    """BobjectSurveyingProject -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    н
    о
    м
    п
    р
    о
    е
    к
    т
    е
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    survey_project_num -- У
    ч
    е
    т
    н
    ы
    й
    н
    о
    м
    е
    р
    п
    р
    о
    е
    к
    т
    а
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    type_boundary -- В
    и
    д
    о
    б
    ъ
    е
    к
    т
    а
    р
    е
    е
    с
    т
    р
    а
    г
    р
    а
    н
    и
    ц
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, survey_project_num=None, type_boundary=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.survey_project_num = survey_project_num
        self.survey_project_num_nsprefix_ = None
        self.type_boundary = type_boundary
        self.type_boundary_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BobjectSurveyingProject)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BobjectSurveyingProject.subclass:
            return BobjectSurveyingProject.subclass(*args_, **kwargs_)
        else:
            return BobjectSurveyingProject(*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_survey_project_num(self):
        return self.survey_project_num
    def set_survey_project_num(self, survey_project_num):
        self.survey_project_num = survey_project_num
    def get_type_boundary(self):
        return self.type_boundary
    def set_type_boundary(self, type_boundary):
        self.type_boundary = type_boundary
    def has__content(self):
        if (
            self.survey_project_num is not None or
            self.type_boundary is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BobjectSurveyingProject', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BobjectSurveyingProject')
        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_ == 'BobjectSurveyingProject':
            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_='BobjectSurveyingProject')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BobjectSurveyingProject', 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_='BobjectSurveyingProject'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BobjectSurveyingProject', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.survey_project_num is not None:
            namespaceprefix_ = self.survey_project_num_nsprefix_ + ':' if (UseCapturedNS_ and self.survey_project_num_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssurvey_project_num>%s</%ssurvey_project_num>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.survey_project_num), input_name='survey_project_num')), namespaceprefix_ , eol_))
        if self.type_boundary is not None:
            namespaceprefix_ = self.type_boundary_nsprefix_ + ':' if (UseCapturedNS_ and self.type_boundary_nsprefix_) else ''
            self.type_boundary.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type_boundary', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'survey_project_num':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'survey_project_num')
            value_ = self.gds_validate_string(value_, node, 'survey_project_num')
            self.survey_project_num = value_
            self.survey_project_num_nsprefix_ = child_.prefix
        elif nodeName_ == 'type_boundary':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_boundary = obj_
            obj_.original_tagname_ = 'type_boundary'
# end class BobjectSurveyingProject


class FormingParcelsNumberContours(GeneratedsSuper):
    """FormingParcelsNumberContours -- О
    б
    р
    а
    з
    у
    е
    м
    ы
    е
    з
    е
    м
    е
    л
    ь
    н
    ы
    е
    у
    ч
    а
    с
    т
    к
    и
    (
    у
    с
    л
    о
    в
    н
    ы
    й
    н
    о
    м
    е
    р
    и
    о
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    )
    forming_parcel -- О
    б
    р
    а
    з
    у
    е
    м
    ы
    й
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, forming_parcel=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 forming_parcel is None:
            self.forming_parcel = []
        else:
            self.forming_parcel = forming_parcel
        self.forming_parcel_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, FormingParcelsNumberContours)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if FormingParcelsNumberContours.subclass:
            return FormingParcelsNumberContours.subclass(*args_, **kwargs_)
        else:
            return FormingParcelsNumberContours(*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_forming_parcel(self):
        return self.forming_parcel
    def set_forming_parcel(self, forming_parcel):
        self.forming_parcel = forming_parcel
    def add_forming_parcel(self, value):
        self.forming_parcel.append(value)
    def insert_forming_parcel_at(self, index, value):
        self.forming_parcel.insert(index, value)
    def replace_forming_parcel_at(self, index, value):
        self.forming_parcel[index] = value
    def has__content(self):
        if (
            self.forming_parcel
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='FormingParcelsNumberContours', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('FormingParcelsNumberContours')
        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_ == 'FormingParcelsNumberContours':
            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_='FormingParcelsNumberContours')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='FormingParcelsNumberContours', 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_='FormingParcelsNumberContours'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='FormingParcelsNumberContours', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for forming_parcel_ in self.forming_parcel:
            namespaceprefix_ = self.forming_parcel_nsprefix_ + ':' if (UseCapturedNS_ and self.forming_parcel_nsprefix_) else ''
            forming_parcel_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forming_parcel', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'forming_parcel':
            obj_ = FormingParcelNumberContours.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forming_parcel.append(obj_)
            obj_.original_tagname_ = 'forming_parcel'
# end class FormingParcelsNumberContours


class FormingParcelNumberContours(GeneratedsSuper):
    """FormingParcelNumberContours -- О
    б
    р
    а
    з
    у
    е
    м
    ы
    й
    з
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    (
    у
    с
    л
    о
    в
    н
    ы
    й
    н
    о
    м
    е
    р
    и
    о
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    )
    nominal_number -- У
    с
    л
    о
    в
    н
    ы
    й
    н
    о
    м
    е
    р
    о
    б
    р
    а
    з
    у
    е
    м
    о
    г
    о
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    zu_contours_location -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    ы
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, nominal_number=None, zu_contours_location=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.nominal_number = nominal_number
        self.validate_nominal_numberType(self.nominal_number)
        self.nominal_number_nsprefix_ = None
        self.zu_contours_location = zu_contours_location
        self.zu_contours_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, FormingParcelNumberContours)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if FormingParcelNumberContours.subclass:
            return FormingParcelNumberContours.subclass(*args_, **kwargs_)
        else:
            return FormingParcelNumberContours(*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_nominal_number(self):
        return self.nominal_number
    def set_nominal_number(self, nominal_number):
        self.nominal_number = nominal_number
    def get_zu_contours_location(self):
        return self.zu_contours_location
    def set_zu_contours_location(self, zu_contours_location):
        self.zu_contours_location = zu_contours_location
    def validate_nominal_numberType(self, value):
        result = True
        # Validate type nominal_numberType, 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
            if len(value) > 50:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxLength restriction on nominal_numberType' % {"value" : encode_str_2_3(value), "lineno": lineno} )
                result = False
            if len(value) < 1:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minLength restriction on nominal_numberType' % {"value" : encode_str_2_3(value), "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.nominal_number is not None or
            self.zu_contours_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='FormingParcelNumberContours', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('FormingParcelNumberContours')
        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_ == 'FormingParcelNumberContours':
            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_='FormingParcelNumberContours')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='FormingParcelNumberContours', 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_='FormingParcelNumberContours'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='FormingParcelNumberContours', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.nominal_number is not None:
            namespaceprefix_ = self.nominal_number_nsprefix_ + ':' if (UseCapturedNS_ and self.nominal_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snominal_number>%s</%snominal_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.nominal_number), input_name='nominal_number')), namespaceprefix_ , eol_))
        if self.zu_contours_location is not None:
            namespaceprefix_ = self.zu_contours_location_nsprefix_ + ':' if (UseCapturedNS_ and self.zu_contours_location_nsprefix_) else ''
            self.zu_contours_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zu_contours_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'nominal_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'nominal_number')
            value_ = self.gds_validate_string(value_, node, 'nominal_number')
            self.nominal_number = value_
            self.nominal_number_nsprefix_ = child_.prefix
            # validate type nominal_numberType
            self.validate_nominal_numberType(self.nominal_number)
        elif nodeName_ == 'zu_contours_location':
            obj_ = BoundContoursLocationOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.zu_contours_location = obj_
            obj_.original_tagname_ = 'zu_contours_location'
# end class FormingParcelNumberContours


class BoundContoursLocationOut(GeneratedsSuper):
    """BoundContoursLocationOut -- К
    о
    н
    т
    у
    р
    ы
    (
    к
    о
    н
    т
    у
    р
    ) (
    к
    о
    о
    р
    д
    и
    н
    а
    т
    ы
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    ,
    з
    а
    к
    р
    е
    п
    л
    е
    н
    и
    е
    н
    а
    м
    е
    с
    т
    н
    о
    с
    т
    и
    и
    м
    е
    т
    о
    д
    о
    п
    р
    е
    д
    е
    л
    е
    н
    и
    я
    )
    contours -- К
    о
    н
    т
    у
    р
    ы
    (
    к
    о
    н
    т
    у
    р
    ) (
    к
    о
    о
    р
    д
    и
    н
    а
    т
    ы
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, contours=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.contours = contours
        self.contours_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BoundContoursLocationOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BoundContoursLocationOut.subclass:
            return BoundContoursLocationOut.subclass(*args_, **kwargs_)
        else:
            return BoundContoursLocationOut(*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_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def has__content(self):
        if (
            self.contours is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BoundContoursLocationOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BoundContoursLocationOut')
        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_ == 'BoundContoursLocationOut':
            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_='BoundContoursLocationOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BoundContoursLocationOut', 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_='BoundContoursLocationOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BoundContoursLocationOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'contours':
            obj_ = BoundContoursOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
# end class BoundContoursLocationOut


class BoundContoursOut(GeneratedsSuper):
    """BoundContoursOut -- К
    о
    н
    т
    у
    р
    ы
    (
    к
    о
    н
    т
    у
    р
    ) (
    к
    о
    о
    р
    д
    и
    н
    а
    т
    ы
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    )
    contour -- К
    о
    н
    т
    у
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, contour=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 contour is None:
            self.contour = []
        else:
            self.contour = contour
        self.contour_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BoundContoursOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BoundContoursOut.subclass:
            return BoundContoursOut.subclass(*args_, **kwargs_)
        else:
            return BoundContoursOut(*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_contour(self):
        return self.contour
    def set_contour(self, contour):
        self.contour = contour
    def add_contour(self, value):
        self.contour.append(value)
    def insert_contour_at(self, index, value):
        self.contour.insert(index, value)
    def replace_contour_at(self, index, value):
        self.contour[index] = value
    def has__content(self):
        if (
            self.contour
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BoundContoursOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BoundContoursOut')
        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_ == 'BoundContoursOut':
            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_='BoundContoursOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BoundContoursOut', 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_='BoundContoursOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BoundContoursOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for contour_ in self.contour:
            namespaceprefix_ = self.contour_nsprefix_ + ':' if (UseCapturedNS_ and self.contour_nsprefix_) else ''
            contour_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contour', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'contour':
            obj_ = BoundContourOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contour.append(obj_)
            obj_.original_tagname_ = 'contour'
# end class BoundContoursOut


class BoundContourOut(GeneratedsSuper):
    """BoundContourOut -- К
    о
    н
    т
    у
    р
    number_pp -- Н
    о
    м
    е
    р
    к
    о
    н
    т
    у
    р
    а
    entity_spatial -- О
    п
    и
    с
    а
    н
    и
    е
    э
    л
    е
    м
    е
    н
    т
    о
    в
    к
    о
    н
    т
    у
    р
    а
    (
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number_pp=None, entity_spatial=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.number_pp = number_pp
        self.number_pp_nsprefix_ = None
        self.entity_spatial = entity_spatial
        self.entity_spatial_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BoundContourOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BoundContourOut.subclass:
            return BoundContourOut.subclass(*args_, **kwargs_)
        else:
            return BoundContourOut(*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_pp(self):
        return self.number_pp
    def set_number_pp(self, number_pp):
        self.number_pp = number_pp
    def get_entity_spatial(self):
        return self.entity_spatial
    def set_entity_spatial(self, entity_spatial):
        self.entity_spatial = entity_spatial
    def has__content(self):
        if (
            self.number_pp is not None or
            self.entity_spatial is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BoundContourOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BoundContourOut')
        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_ == 'BoundContourOut':
            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_='BoundContourOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BoundContourOut', 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_='BoundContourOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BoundContourOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number_pp is not None:
            namespaceprefix_ = self.number_pp_nsprefix_ + ':' if (UseCapturedNS_ and self.number_pp_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber_pp>%s</%snumber_pp>%s' % (namespaceprefix_ , self.gds_format_integer(self.number_pp, input_name='number_pp'), namespaceprefix_ , eol_))
        if self.entity_spatial is not None:
            namespaceprefix_ = self.entity_spatial_nsprefix_ + ':' if (UseCapturedNS_ and self.entity_spatial_nsprefix_) else ''
            self.entity_spatial.export(outfile, level, namespaceprefix_, namespacedef_='', name_='entity_spatial', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number_pp' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'number_pp')
            ival_ = self.gds_validate_integer(ival_, node, 'number_pp')
            self.number_pp = ival_
            self.number_pp_nsprefix_ = child_.prefix
        elif nodeName_ == 'entity_spatial':
            obj_ = EntitySpatialBound.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.entity_spatial = obj_
            obj_.original_tagname_ = 'entity_spatial'
# end class BoundContourOut


class EntitySpatialBound(GeneratedsSuper):
    """EntitySpatialBound -- О
    п
    и
    с
    а
    н
    и
    е
    э
    л
    е
    м
    е
    н
    т
    о
    в
    к
    о
    н
    т
    у
    р
    а
    (
    х
    а
    р
    а
    к
    т
    е
    р
    н
    ы
    х
    т
    о
    ч
    е
    к
    к
    о
    н
    т
    у
    р
    а
    )
    sk_id -- С
    и
    с
    т
    е
    м
    а
    к
    о
    о
    р
    д
    и
    н
    а
    т
    spatials_elements -- Э
    л
    е
    м
    е
    н
    т
    ы
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, sk_id=None, spatials_elements=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.sk_id = sk_id
        self.sk_id_nsprefix_ = None
        self.spatials_elements = spatials_elements
        self.spatials_elements_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, EntitySpatialBound)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if EntitySpatialBound.subclass:
            return EntitySpatialBound.subclass(*args_, **kwargs_)
        else:
            return EntitySpatialBound(*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_sk_id(self):
        return self.sk_id
    def set_sk_id(self, sk_id):
        self.sk_id = sk_id
    def get_spatials_elements(self):
        return self.spatials_elements
    def set_spatials_elements(self, spatials_elements):
        self.spatials_elements = spatials_elements
    def has__content(self):
        if (
            self.sk_id is not None or
            self.spatials_elements is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntitySpatialBound', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('EntitySpatialBound')
        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_ == 'EntitySpatialBound':
            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_='EntitySpatialBound')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='EntitySpatialBound', 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_='EntitySpatialBound'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntitySpatialBound', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.sk_id is not None:
            namespaceprefix_ = self.sk_id_nsprefix_ + ':' if (UseCapturedNS_ and self.sk_id_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssk_id>%s</%ssk_id>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.sk_id), input_name='sk_id')), namespaceprefix_ , eol_))
        if self.spatials_elements is not None:
            namespaceprefix_ = self.spatials_elements_nsprefix_ + ':' if (UseCapturedNS_ and self.spatials_elements_nsprefix_) else ''
            self.spatials_elements.export(outfile, level, namespaceprefix_, namespacedef_='', name_='spatials_elements', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'sk_id':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'sk_id')
            value_ = self.gds_validate_string(value_, node, 'sk_id')
            self.sk_id = value_
            self.sk_id_nsprefix_ = child_.prefix
        elif nodeName_ == 'spatials_elements':
            obj_ = SpatialsElementsBound.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.spatials_elements = obj_
            obj_.original_tagname_ = 'spatials_elements'
# end class EntitySpatialBound


class SpatialsElementsBound(GeneratedsSuper):
    """SpatialsElementsBound -- Э
    л
    е
    м
    е
    н
    т
    ы
    к
    о
    н
    т
    у
    р
    а
    (
    и
    о
    п
    и
    с
    а
    н
    и
    е
    з
    а
    к
    р
    е
    п
    л
    е
    н
    и
    я
    т
    о
    ч
    к
    и
    ,
    м
    е
    т
    о
    д
    о
    п
    р
    е
    д
    е
    л
    е
    н
    и
    я
    к
    о
    о
    р
    д
    и
    н
    а
    т
    )
    spatial_element -- Э
    л
    е
    м
    е
    н
    т
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, spatial_element=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 spatial_element is None:
            self.spatial_element = []
        else:
            self.spatial_element = spatial_element
        self.spatial_element_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpatialsElementsBound)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpatialsElementsBound.subclass:
            return SpatialsElementsBound.subclass(*args_, **kwargs_)
        else:
            return SpatialsElementsBound(*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_spatial_element(self):
        return self.spatial_element
    def set_spatial_element(self, spatial_element):
        self.spatial_element = spatial_element
    def add_spatial_element(self, value):
        self.spatial_element.append(value)
    def insert_spatial_element_at(self, index, value):
        self.spatial_element.insert(index, value)
    def replace_spatial_element_at(self, index, value):
        self.spatial_element[index] = value
    def has__content(self):
        if (
            self.spatial_element
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialsElementsBound', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpatialsElementsBound')
        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_ == 'SpatialsElementsBound':
            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_='SpatialsElementsBound')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpatialsElementsBound', 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_='SpatialsElementsBound'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialsElementsBound', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for spatial_element_ in self.spatial_element:
            namespaceprefix_ = self.spatial_element_nsprefix_ + ':' if (UseCapturedNS_ and self.spatial_element_nsprefix_) else ''
            spatial_element_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='spatial_element', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'spatial_element':
            obj_ = SpatialElementBound.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.spatial_element.append(obj_)
            obj_.original_tagname_ = 'spatial_element'
# end class SpatialsElementsBound


class SpatialElementBound(GeneratedsSuper):
    """SpatialElementBound -- Э
    л
    е
    м
    е
    н
    т
    к
    о
    н
    т
    у
    р
    а
    ordinates -- С
    п
    и
    с
    о
    к
    к
    о
    о
    р
    д
    и
    н
    а
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ordinates=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.ordinates = ordinates
        self.ordinates_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpatialElementBound)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpatialElementBound.subclass:
            return SpatialElementBound.subclass(*args_, **kwargs_)
        else:
            return SpatialElementBound(*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_ordinates(self):
        return self.ordinates
    def set_ordinates(self, ordinates):
        self.ordinates = ordinates
    def has__content(self):
        if (
            self.ordinates is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialElementBound', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpatialElementBound')
        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_ == 'SpatialElementBound':
            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_='SpatialElementBound')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpatialElementBound', 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_='SpatialElementBound'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialElementBound', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ordinates is not None:
            namespaceprefix_ = self.ordinates_nsprefix_ + ':' if (UseCapturedNS_ and self.ordinates_nsprefix_) else ''
            self.ordinates.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ordinates', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ordinates':
            obj_ = OrdinatesBound.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ordinates = obj_
            obj_.original_tagname_ = 'ordinates'
# end class SpatialElementBound


class OrdinatesBound(GeneratedsSuper):
    """OrdinatesBound -- С
    п
    и
    с
    о
    к
    к
    о
    о
    р
    д
    и
    н
    а
    т
    ordinate -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ordinate=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 ordinate is None:
            self.ordinate = []
        else:
            self.ordinate = ordinate
        self.ordinate_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OrdinatesBound)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OrdinatesBound.subclass:
            return OrdinatesBound.subclass(*args_, **kwargs_)
        else:
            return OrdinatesBound(*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_ordinate(self):
        return self.ordinate
    def set_ordinate(self, ordinate):
        self.ordinate = ordinate
    def add_ordinate(self, value):
        self.ordinate.append(value)
    def insert_ordinate_at(self, index, value):
        self.ordinate.insert(index, value)
    def replace_ordinate_at(self, index, value):
        self.ordinate[index] = value
    def has__content(self):
        if (
            self.ordinate
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinatesBound', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OrdinatesBound')
        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_ == 'OrdinatesBound':
            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_='OrdinatesBound')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OrdinatesBound', 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_='OrdinatesBound'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinatesBound', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ordinate_ in self.ordinate:
            namespaceprefix_ = self.ordinate_nsprefix_ + ':' if (UseCapturedNS_ and self.ordinate_nsprefix_) else ''
            ordinate_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ordinate', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ordinate':
            obj_ = OrdinateBound.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ordinate.append(obj_)
            obj_.original_tagname_ = 'ordinate'
# end class OrdinatesBound


class OrdinateBound(GeneratedsSuper):
    """OrdinateBound -- К
    о
    о
    р
    д
    и
    н
    а
    т
    ы
    ,
    о
    п
    и
    с
    а
    н
    и
    е
    з
    а
    к
    р
    е
    п
    л
    е
    н
    и
    я
    т
    о
    ч
    к
    и
    ,
    м
    е
    т
    о
    д
    о
    п
    р
    е
    д
    е
    л
    е
    н
    и
    я
    к
    о
    о
    р
    д
    и
    н
    а
    т
    x -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    X
    y -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    Y
    ord_nmb -- Н
    о
    м
    е
    р
    т
    о
    ч
    к
    и
    (
    п
    о
    р
    я
    д
    о
    к
    о
    б
    х
    о
    д
    а
    )
    num_geopoint -- Н
    о
    м
    е
    р
    м
    е
    ж
    е
    в
    о
    й
    т
    о
    ч
    к
    и
    geopoint_zacrep -- О
    п
    и
    с
    а
    н
    и
    е
    з
    а
    к
    р
    е
    п
    л
    е
    н
    и
    я
    т
    о
    ч
    к
    и
    geopoint_opred -- М
    е
    т
    о
    д
    о
    п
    р
    е
    д
    е
    л
    е
    н
    и
    я
    к
    о
    о
    р
    д
    и
    н
    а
    т
    delta_geopoint -- П
    о
    г
    р
    е
    ш
    н
    о
    с
    т
    ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, x=None, y=None, ord_nmb=None, num_geopoint=None, geopoint_zacrep=None, geopoint_opred=None, delta_geopoint=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.x = x
        self.x_nsprefix_ = None
        self.y = y
        self.y_nsprefix_ = None
        self.ord_nmb = ord_nmb
        self.ord_nmb_nsprefix_ = None
        self.num_geopoint = num_geopoint
        self.num_geopoint_nsprefix_ = None
        self.geopoint_zacrep = geopoint_zacrep
        self.geopoint_zacrep_nsprefix_ = None
        self.geopoint_opred = geopoint_opred
        self.geopoint_opred_nsprefix_ = None
        self.delta_geopoint = delta_geopoint
        self.delta_geopoint_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OrdinateBound)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OrdinateBound.subclass:
            return OrdinateBound.subclass(*args_, **kwargs_)
        else:
            return OrdinateBound(*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_x(self):
        return self.x
    def set_x(self, x):
        self.x = x
    def get_y(self):
        return self.y
    def set_y(self, y):
        self.y = y
    def get_ord_nmb(self):
        return self.ord_nmb
    def set_ord_nmb(self, ord_nmb):
        self.ord_nmb = ord_nmb
    def get_num_geopoint(self):
        return self.num_geopoint
    def set_num_geopoint(self, num_geopoint):
        self.num_geopoint = num_geopoint
    def get_geopoint_zacrep(self):
        return self.geopoint_zacrep
    def set_geopoint_zacrep(self, geopoint_zacrep):
        self.geopoint_zacrep = geopoint_zacrep
    def get_geopoint_opred(self):
        return self.geopoint_opred
    def set_geopoint_opred(self, geopoint_opred):
        self.geopoint_opred = geopoint_opred
    def get_delta_geopoint(self):
        return self.delta_geopoint
    def set_delta_geopoint(self, delta_geopoint):
        self.delta_geopoint = delta_geopoint
    def has__content(self):
        if (
            self.x is not None or
            self.y is not None or
            self.ord_nmb is not None or
            self.num_geopoint is not None or
            self.geopoint_zacrep is not None or
            self.geopoint_opred is not None or
            self.delta_geopoint is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinateBound', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OrdinateBound')
        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_ == 'OrdinateBound':
            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_='OrdinateBound')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OrdinateBound', 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_='OrdinateBound'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OrdinateBound', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.x is not None:
            namespaceprefix_ = self.x_nsprefix_ + ':' if (UseCapturedNS_ and self.x_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sx>%s</%sx>%s' % (namespaceprefix_ , self.gds_format_decimal(self.x, input_name='x'), namespaceprefix_ , eol_))
        if self.y is not None:
            namespaceprefix_ = self.y_nsprefix_ + ':' if (UseCapturedNS_ and self.y_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sy>%s</%sy>%s' % (namespaceprefix_ , self.gds_format_decimal(self.y, input_name='y'), namespaceprefix_ , eol_))
        if self.ord_nmb is not None:
            namespaceprefix_ = self.ord_nmb_nsprefix_ + ':' if (UseCapturedNS_ and self.ord_nmb_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sord_nmb>%s</%sord_nmb>%s' % (namespaceprefix_ , self.gds_format_integer(self.ord_nmb, input_name='ord_nmb'), namespaceprefix_ , eol_))
        if self.num_geopoint is not None:
            namespaceprefix_ = self.num_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.num_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snum_geopoint>%s</%snum_geopoint>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.num_geopoint), input_name='num_geopoint')), namespaceprefix_ , eol_))
        if self.geopoint_zacrep is not None:
            namespaceprefix_ = self.geopoint_zacrep_nsprefix_ + ':' if (UseCapturedNS_ and self.geopoint_zacrep_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sgeopoint_zacrep>%s</%sgeopoint_zacrep>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.geopoint_zacrep), input_name='geopoint_zacrep')), namespaceprefix_ , eol_))
        if self.geopoint_opred is not None:
            namespaceprefix_ = self.geopoint_opred_nsprefix_ + ':' if (UseCapturedNS_ and self.geopoint_opred_nsprefix_) else ''
            self.geopoint_opred.export(outfile, level, namespaceprefix_, namespacedef_='', name_='geopoint_opred', pretty_print=pretty_print)
        if self.delta_geopoint is not None:
            namespaceprefix_ = self.delta_geopoint_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_geopoint_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdelta_geopoint>%s</%sdelta_geopoint>%s' % (namespaceprefix_ , self.gds_format_decimal(self.delta_geopoint, input_name='delta_geopoint'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'x' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'x')
            fval_ = self.gds_validate_decimal(fval_, node, 'x')
            self.x = fval_
            self.x_nsprefix_ = child_.prefix
        elif nodeName_ == 'y' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'y')
            fval_ = self.gds_validate_decimal(fval_, node, 'y')
            self.y = fval_
            self.y_nsprefix_ = child_.prefix
        elif nodeName_ == 'ord_nmb' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'ord_nmb')
            ival_ = self.gds_validate_integer(ival_, node, 'ord_nmb')
            self.ord_nmb = ival_
            self.ord_nmb_nsprefix_ = child_.prefix
        elif nodeName_ == 'num_geopoint':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'num_geopoint')
            value_ = self.gds_validate_string(value_, node, 'num_geopoint')
            self.num_geopoint = value_
            self.num_geopoint_nsprefix_ = child_.prefix
        elif nodeName_ == 'geopoint_zacrep':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'geopoint_zacrep')
            value_ = self.gds_validate_string(value_, node, 'geopoint_zacrep')
            self.geopoint_zacrep = value_
            self.geopoint_zacrep_nsprefix_ = child_.prefix
        elif nodeName_ == 'geopoint_opred':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.geopoint_opred = obj_
            obj_.original_tagname_ = 'geopoint_opred'
        elif nodeName_ == 'delta_geopoint' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'delta_geopoint')
            fval_ = self.gds_validate_decimal(fval_, node, 'delta_geopoint')
            self.delta_geopoint = fval_
            self.delta_geopoint_nsprefix_ = child_.prefix
# end class OrdinateBound


class OMSPoints(GeneratedsSuper):
    """OMSPoints -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    у
    н
    к
    т
    а
    х
    О
    М
    С
    oms_point -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    у
    н
    к
    т
    е
    О
    М
    С
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, oms_point=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 oms_point is None:
            self.oms_point = []
        else:
            self.oms_point = oms_point
        self.oms_point_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OMSPoints)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OMSPoints.subclass:
            return OMSPoints.subclass(*args_, **kwargs_)
        else:
            return OMSPoints(*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_oms_point(self):
        return self.oms_point
    def set_oms_point(self, oms_point):
        self.oms_point = oms_point
    def add_oms_point(self, value):
        self.oms_point.append(value)
    def insert_oms_point_at(self, index, value):
        self.oms_point.insert(index, value)
    def replace_oms_point_at(self, index, value):
        self.oms_point[index] = value
    def has__content(self):
        if (
            self.oms_point
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OMSPoints', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OMSPoints')
        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_ == 'OMSPoints':
            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_='OMSPoints')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OMSPoints', 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_='OMSPoints'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OMSPoints', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for oms_point_ in self.oms_point:
            namespaceprefix_ = self.oms_point_nsprefix_ + ':' if (UseCapturedNS_ and self.oms_point_nsprefix_) else ''
            oms_point_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='oms_point', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'oms_point':
            obj_ = OMSPoint.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.oms_point.append(obj_)
            obj_.original_tagname_ = 'oms_point'
# end class OMSPoints


class OMSPoint(GeneratedsSuper):
    """OMSPoint -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    у
    н
    к
    т
    е
    О
    М
    С
    p_nmb -- Н
    о
    м
    е
    р
    п
    у
    н
    к
    т
    а
    о
    п
    о
    р
    н
    о
    й
    м
    е
    ж
    е
    в
    о
    й
    с
    е
    т
    и
    н
    а
    п
    л
    а
    н
    е
    p_name -- Н
    а
    з
    в
    а
    н
    и
    е
    и
    т
    и
    п
    п
    у
    н
    к
    т
    а
    p_klass -- К
    л
    а
    с
    с
    г
    е
    о
    д
    е
    з
    и
    ч
    е
    с
    к
    о
    й
    с
    е
    т
    и
    ord_x -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    Х
    ord_y -- К
    о
    о
    р
    д
    и
    н
    а
    т
    а
    У
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, p_nmb=None, p_name=None, p_klass=None, ord_x=None, ord_y=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.p_nmb = p_nmb
        self.p_nmb_nsprefix_ = None
        self.p_name = p_name
        self.p_name_nsprefix_ = None
        self.p_klass = p_klass
        self.p_klass_nsprefix_ = None
        self.ord_x = ord_x
        self.ord_x_nsprefix_ = None
        self.ord_y = ord_y
        self.ord_y_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OMSPoint)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OMSPoint.subclass:
            return OMSPoint.subclass(*args_, **kwargs_)
        else:
            return OMSPoint(*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_p_nmb(self):
        return self.p_nmb
    def set_p_nmb(self, p_nmb):
        self.p_nmb = p_nmb
    def get_p_name(self):
        return self.p_name
    def set_p_name(self, p_name):
        self.p_name = p_name
    def get_p_klass(self):
        return self.p_klass
    def set_p_klass(self, p_klass):
        self.p_klass = p_klass
    def get_ord_x(self):
        return self.ord_x
    def set_ord_x(self, ord_x):
        self.ord_x = ord_x
    def get_ord_y(self):
        return self.ord_y
    def set_ord_y(self, ord_y):
        self.ord_y = ord_y
    def has__content(self):
        if (
            self.p_nmb is not None or
            self.p_name is not None or
            self.p_klass is not None or
            self.ord_x is not None or
            self.ord_y is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OMSPoint', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OMSPoint')
        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_ == 'OMSPoint':
            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_='OMSPoint')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OMSPoint', 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_='OMSPoint'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OMSPoint', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.p_nmb is not None:
            namespaceprefix_ = self.p_nmb_nsprefix_ + ':' if (UseCapturedNS_ and self.p_nmb_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sp_nmb>%s</%sp_nmb>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.p_nmb), input_name='p_nmb')), namespaceprefix_ , eol_))
        if self.p_name is not None:
            namespaceprefix_ = self.p_name_nsprefix_ + ':' if (UseCapturedNS_ and self.p_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sp_name>%s</%sp_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.p_name), input_name='p_name')), namespaceprefix_ , eol_))
        if self.p_klass is not None:
            namespaceprefix_ = self.p_klass_nsprefix_ + ':' if (UseCapturedNS_ and self.p_klass_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sp_klass>%s</%sp_klass>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.p_klass), input_name='p_klass')), namespaceprefix_ , eol_))
        if self.ord_x is not None:
            namespaceprefix_ = self.ord_x_nsprefix_ + ':' if (UseCapturedNS_ and self.ord_x_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sord_x>%s</%sord_x>%s' % (namespaceprefix_ , self.gds_format_decimal(self.ord_x, input_name='ord_x'), namespaceprefix_ , eol_))
        if self.ord_y is not None:
            namespaceprefix_ = self.ord_y_nsprefix_ + ':' if (UseCapturedNS_ and self.ord_y_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sord_y>%s</%sord_y>%s' % (namespaceprefix_ , self.gds_format_decimal(self.ord_y, input_name='ord_y'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'p_nmb':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'p_nmb')
            value_ = self.gds_validate_string(value_, node, 'p_nmb')
            self.p_nmb = value_
            self.p_nmb_nsprefix_ = child_.prefix
        elif nodeName_ == 'p_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'p_name')
            value_ = self.gds_validate_string(value_, node, 'p_name')
            self.p_name = value_
            self.p_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'p_klass':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'p_klass')
            value_ = self.gds_validate_string(value_, node, 'p_klass')
            self.p_klass = value_
            self.p_klass_nsprefix_ = child_.prefix
        elif nodeName_ == 'ord_x' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'ord_x')
            fval_ = self.gds_validate_decimal(fval_, node, 'ord_x')
            self.ord_x = fval_
            self.ord_x_nsprefix_ = child_.prefix
        elif nodeName_ == 'ord_y' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'ord_y')
            fval_ = self.gds_validate_decimal(fval_, node, 'ord_y')
            self.ord_y = fval_
            self.ord_y_nsprefix_ = child_.prefix
# end class OMSPoint


class RecordData(GeneratedsSuper):
    """RecordData -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    в
    к
    а
    д
    а
    с
    т
    р
    о
    в
    о
    м
    к
    в
    а
    р
    т
    а
    л
    е
    base_data -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, base_data=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.base_data = base_data
        self.base_data_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RecordData)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RecordData.subclass:
            return RecordData.subclass(*args_, **kwargs_)
        else:
            return RecordData(*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_base_data(self):
        return self.base_data
    def set_base_data(self, base_data):
        self.base_data = base_data
    def has__content(self):
        if (
            self.base_data is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RecordData', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RecordData')
        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_ == 'RecordData':
            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_='RecordData')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RecordData', 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_='RecordData'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RecordData', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.base_data is not None:
            namespaceprefix_ = self.base_data_nsprefix_ + ':' if (UseCapturedNS_ and self.base_data_nsprefix_) else ''
            self.base_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='base_data', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'base_data':
            obj_ = BaseDataType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.base_data = obj_
            obj_.original_tagname_ = 'base_data'
# end class RecordData


class BaseDataType(GeneratedsSuper):
    """BaseDataType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    land_records -- З
    е
    м
    е
    л
    ь
    н
    ы
    е
    у
    ч
    а
    с
    т
    к
    и
    build_records -- З
    д
    а
    н
    и
    я
    construction_records -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    object_under_construction_records -- О
    б
    ъ
    е
    к
    т
    ы
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_records=None, build_records=None, construction_records=None, object_under_construction_records=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.land_records = land_records
        self.land_records_nsprefix_ = None
        self.build_records = build_records
        self.build_records_nsprefix_ = None
        self.construction_records = construction_records
        self.construction_records_nsprefix_ = None
        self.object_under_construction_records = object_under_construction_records
        self.object_under_construction_records_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BaseDataType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BaseDataType.subclass:
            return BaseDataType.subclass(*args_, **kwargs_)
        else:
            return BaseDataType(*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_land_records(self):
        return self.land_records
    def set_land_records(self, land_records):
        self.land_records = land_records
    def get_build_records(self):
        return self.build_records
    def set_build_records(self, build_records):
        self.build_records = build_records
    def get_construction_records(self):
        return self.construction_records
    def set_construction_records(self, construction_records):
        self.construction_records = construction_records
    def get_object_under_construction_records(self):
        return self.object_under_construction_records
    def set_object_under_construction_records(self, object_under_construction_records):
        self.object_under_construction_records = object_under_construction_records
    def has__content(self):
        if (
            self.land_records is not None or
            self.build_records is not None or
            self.construction_records is not None or
            self.object_under_construction_records is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BaseDataType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BaseDataType')
        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_ == 'BaseDataType':
            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_='BaseDataType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BaseDataType', 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_='BaseDataType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BaseDataType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.land_records is not None:
            namespaceprefix_ = self.land_records_nsprefix_ + ':' if (UseCapturedNS_ and self.land_records_nsprefix_) else ''
            self.land_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_records', pretty_print=pretty_print)
        if self.build_records is not None:
            namespaceprefix_ = self.build_records_nsprefix_ + ':' if (UseCapturedNS_ and self.build_records_nsprefix_) else ''
            self.build_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='build_records', pretty_print=pretty_print)
        if self.construction_records is not None:
            namespaceprefix_ = self.construction_records_nsprefix_ + ':' if (UseCapturedNS_ and self.construction_records_nsprefix_) else ''
            self.construction_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='construction_records', pretty_print=pretty_print)
        if self.object_under_construction_records is not None:
            namespaceprefix_ = self.object_under_construction_records_nsprefix_ + ':' if (UseCapturedNS_ and self.object_under_construction_records_nsprefix_) else ''
            self.object_under_construction_records.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_under_construction_records', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_records':
            obj_ = land_recordsType11.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_records = obj_
            obj_.original_tagname_ = 'land_records'
        elif nodeName_ == 'build_records':
            obj_ = build_recordsType12.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.build_records = obj_
            obj_.original_tagname_ = 'build_records'
        elif nodeName_ == 'construction_records':
            obj_ = construction_recordsType13.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.construction_records = obj_
            obj_.original_tagname_ = 'construction_records'
        elif nodeName_ == 'object_under_construction_records':
            obj_ = object_under_construction_recordsType14.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_under_construction_records = obj_
            obj_.original_tagname_ = 'object_under_construction_records'
# end class BaseDataType


class SpatialDataType(GeneratedsSuper):
    """SpatialDataType -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    к
    в
    а
    р
    т
    а
    л
    а
    entity_spatial -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, entity_spatial=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.entity_spatial = entity_spatial
        self.entity_spatial_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SpatialDataType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SpatialDataType.subclass:
            return SpatialDataType.subclass(*args_, **kwargs_)
        else:
            return SpatialDataType(*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_entity_spatial(self):
        return self.entity_spatial
    def set_entity_spatial(self, entity_spatial):
        self.entity_spatial = entity_spatial
    def has__content(self):
        if (
            self.entity_spatial is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialDataType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SpatialDataType')
        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_ == 'SpatialDataType':
            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_='SpatialDataType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SpatialDataType', 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_='SpatialDataType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SpatialDataType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.entity_spatial is not None:
            namespaceprefix_ = self.entity_spatial_nsprefix_ + ':' if (UseCapturedNS_ and self.entity_spatial_nsprefix_) else ''
            self.entity_spatial.export(outfile, level, namespaceprefix_, namespacedef_='', name_='entity_spatial', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'entity_spatial':
            obj_ = EntitySpatialBound.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.entity_spatial = obj_
            obj_.original_tagname_ = 'entity_spatial'
# end class SpatialDataType


class SubjectBoundariesType(GeneratedsSuper):
    """SubjectBoundariesType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    е
    м
    е
    ж
    д
    у
    с
    у
    б
    ъ
    е
    к
    т
    а
    м
    и
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    subject_boundary_record -- Г
    р
    а
    н
    и
    ц
    а
    м
    е
    ж
    д
    у
    с
    у
    б
    ъ
    е
    к
    т
    а
    м
    и
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, subject_boundary_record=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 subject_boundary_record is None:
            self.subject_boundary_record = []
        else:
            self.subject_boundary_record = subject_boundary_record
        self.subject_boundary_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SubjectBoundariesType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SubjectBoundariesType.subclass:
            return SubjectBoundariesType.subclass(*args_, **kwargs_)
        else:
            return SubjectBoundariesType(*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_subject_boundary_record(self):
        return self.subject_boundary_record
    def set_subject_boundary_record(self, subject_boundary_record):
        self.subject_boundary_record = subject_boundary_record
    def add_subject_boundary_record(self, value):
        self.subject_boundary_record.append(value)
    def insert_subject_boundary_record_at(self, index, value):
        self.subject_boundary_record.insert(index, value)
    def replace_subject_boundary_record_at(self, index, value):
        self.subject_boundary_record[index] = value
    def has__content(self):
        if (
            self.subject_boundary_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SubjectBoundariesType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SubjectBoundariesType')
        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_ == 'SubjectBoundariesType':
            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_='SubjectBoundariesType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SubjectBoundariesType', 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_='SubjectBoundariesType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SubjectBoundariesType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for subject_boundary_record_ in self.subject_boundary_record:
            namespaceprefix_ = self.subject_boundary_record_nsprefix_ + ':' if (UseCapturedNS_ and self.subject_boundary_record_nsprefix_) else ''
            subject_boundary_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subject_boundary_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'subject_boundary_record':
            obj_ = subject_boundary_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.subject_boundary_record.append(obj_)
            obj_.original_tagname_ = 'subject_boundary_record'
# end class SubjectBoundariesType


class MunicipalBoundariesType(GeneratedsSuper):
    """MunicipalBoundariesType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    а
    х
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    й
    municipal_boundary_record -- Г
    р
    а
    н
    и
    ц
    а
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    о
    г
    о
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, municipal_boundary_record=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 municipal_boundary_record is None:
            self.municipal_boundary_record = []
        else:
            self.municipal_boundary_record = municipal_boundary_record
        self.municipal_boundary_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, MunicipalBoundariesType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if MunicipalBoundariesType.subclass:
            return MunicipalBoundariesType.subclass(*args_, **kwargs_)
        else:
            return MunicipalBoundariesType(*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_municipal_boundary_record(self):
        return self.municipal_boundary_record
    def set_municipal_boundary_record(self, municipal_boundary_record):
        self.municipal_boundary_record = municipal_boundary_record
    def add_municipal_boundary_record(self, value):
        self.municipal_boundary_record.append(value)
    def insert_municipal_boundary_record_at(self, index, value):
        self.municipal_boundary_record.insert(index, value)
    def replace_municipal_boundary_record_at(self, index, value):
        self.municipal_boundary_record[index] = value
    def has__content(self):
        if (
            self.municipal_boundary_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MunicipalBoundariesType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('MunicipalBoundariesType')
        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_ == 'MunicipalBoundariesType':
            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_='MunicipalBoundariesType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MunicipalBoundariesType', 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_='MunicipalBoundariesType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MunicipalBoundariesType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for municipal_boundary_record_ in self.municipal_boundary_record:
            namespaceprefix_ = self.municipal_boundary_record_nsprefix_ + ':' if (UseCapturedNS_ and self.municipal_boundary_record_nsprefix_) else ''
            municipal_boundary_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='municipal_boundary_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'municipal_boundary_record':
            obj_ = municipal_boundary_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.municipal_boundary_record.append(obj_)
            obj_.original_tagname_ = 'municipal_boundary_record'
# end class MunicipalBoundariesType


class InhabitedLocalityBoundariesType(GeneratedsSuper):
    """InhabitedLocalityBoundariesType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    а
    х
    н
    а
    с
    е
    л
    ё
    н
    н
    ы
    х
    п
    у
    н
    к
    т
    о
    в
    inhabited_locality_boundary_record -- Г
    р
    а
    н
    и
    ц
    а
    н
    а
    с
    е
    л
    ё
    н
    н
    о
    г
    о
    п
    у
    н
    к
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, inhabited_locality_boundary_record=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 inhabited_locality_boundary_record is None:
            self.inhabited_locality_boundary_record = []
        else:
            self.inhabited_locality_boundary_record = inhabited_locality_boundary_record
        self.inhabited_locality_boundary_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, InhabitedLocalityBoundariesType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if InhabitedLocalityBoundariesType.subclass:
            return InhabitedLocalityBoundariesType.subclass(*args_, **kwargs_)
        else:
            return InhabitedLocalityBoundariesType(*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_inhabited_locality_boundary_record(self):
        return self.inhabited_locality_boundary_record
    def set_inhabited_locality_boundary_record(self, inhabited_locality_boundary_record):
        self.inhabited_locality_boundary_record = inhabited_locality_boundary_record
    def add_inhabited_locality_boundary_record(self, value):
        self.inhabited_locality_boundary_record.append(value)
    def insert_inhabited_locality_boundary_record_at(self, index, value):
        self.inhabited_locality_boundary_record.insert(index, value)
    def replace_inhabited_locality_boundary_record_at(self, index, value):
        self.inhabited_locality_boundary_record[index] = value
    def has__content(self):
        if (
            self.inhabited_locality_boundary_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='InhabitedLocalityBoundariesType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('InhabitedLocalityBoundariesType')
        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_ == 'InhabitedLocalityBoundariesType':
            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_='InhabitedLocalityBoundariesType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='InhabitedLocalityBoundariesType', 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_='InhabitedLocalityBoundariesType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='InhabitedLocalityBoundariesType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for inhabited_locality_boundary_record_ in self.inhabited_locality_boundary_record:
            namespaceprefix_ = self.inhabited_locality_boundary_record_nsprefix_ + ':' if (UseCapturedNS_ and self.inhabited_locality_boundary_record_nsprefix_) else ''
            inhabited_locality_boundary_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='inhabited_locality_boundary_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'inhabited_locality_boundary_record':
            obj_ = inhabited_locality_boundary_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.inhabited_locality_boundary_record.append(obj_)
            obj_.original_tagname_ = 'inhabited_locality_boundary_record'
# end class InhabitedLocalityBoundariesType


class CoastlineBoundariesType(GeneratedsSuper):
    """CoastlineBoundariesType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    е
    р
    е
    г
    о
    в
    ы
    х
    л
    и
    н
    и
    я
    х
    (
    г
    р
    а
    н
    и
    ц
    а
    х
    в
    о
    д
    н
    ы
    х
    о
    б
    ъ
    е
    к
    т
    о
    в
    )
    coastline_record -- Б
    е
    р
    е
    г
    о
    в
    а
    я
    л
    и
    н
    и
    я
    (
    г
    р
    а
    н
    и
    ц
    а
    в
    о
    д
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, coastline_record=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 coastline_record is None:
            self.coastline_record = []
        else:
            self.coastline_record = coastline_record
        self.coastline_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CoastlineBoundariesType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CoastlineBoundariesType.subclass:
            return CoastlineBoundariesType.subclass(*args_, **kwargs_)
        else:
            return CoastlineBoundariesType(*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_coastline_record(self):
        return self.coastline_record
    def set_coastline_record(self, coastline_record):
        self.coastline_record = coastline_record
    def add_coastline_record(self, value):
        self.coastline_record.append(value)
    def insert_coastline_record_at(self, index, value):
        self.coastline_record.insert(index, value)
    def replace_coastline_record_at(self, index, value):
        self.coastline_record[index] = value
    def has__content(self):
        if (
            self.coastline_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CoastlineBoundariesType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CoastlineBoundariesType')
        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_ == 'CoastlineBoundariesType':
            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_='CoastlineBoundariesType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CoastlineBoundariesType', 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_='CoastlineBoundariesType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CoastlineBoundariesType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for coastline_record_ in self.coastline_record:
            namespaceprefix_ = self.coastline_record_nsprefix_ + ':' if (UseCapturedNS_ and self.coastline_record_nsprefix_) else ''
            coastline_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='coastline_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'coastline_record':
            obj_ = coastline_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.coastline_record.append(obj_)
            obj_.original_tagname_ = 'coastline_record'
# end class CoastlineBoundariesType


class ZonesAndTerritoriesBoundariesType(GeneratedsSuper):
    """ZonesAndTerritoriesBoundariesType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    з
    о
    н
    а
    х
    с
    о
    с
    о
    б
    ы
    м
    и
    у
    с
    л
    о
    в
    и
    я
    м
    и
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    й
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    а
    л
    ь
    н
    ы
    х
    з
    о
    н
    а
    х
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    я
    х
    о
    б
    ъ
    е
    к
    т
    о
    в
    к
    у
    л
    ь
    т
    у
    р
    н
    о
    г
    о
    н
    а
    с
    л
    е
    д
    и
    я
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    я
    х
    о
    п
    е
    р
    е
    ж
    а
    ю
    щ
    е
    г
    о
    с
    о
    ц
    и
    а
    л
    ь
    н
    о
    -
    э
    к
    о
    н
    о
    м
    и
    ч
    е
    с
    к
    о
    г
    о
    р
    а
    з
    в
    и
    т
    и
    я
    ,
    з
    о
    н
    а
    х
    т
    е
    р
    р
    и
    т
    о
    р
    и
    а
    л
    ь
    н
    о
    г
    о
    р
    а
    з
    в
    и
    т
    и
    я
    ,
    и
    г
    о
    р
    н
    ы
    х
    з
    о
    н
    а
    х
    ,
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    а
    х
    ,
    л
    е
    с
    о
    п
    а
    р
    к
    а
    х
    ,
    о
    с
    о
    б
    о
    о
    х
    р
    а
    н
    я
    е
    м
    ы
    х
    п
    р
    и
    р
    о
    д
    н
    ы
    х
    т
    е
    р
    р
    и
    т
    о
    р
    и
    я
    х
    ,
    о
    с
    о
    б
    ы
    х
    э
    к
    о
    н
    о
    м
    и
    ч
    е
    с
    к
    и
    х
    з
    о
    н
    а
    х
    ,
    о
    х
    о
    т
    н
    и
    ч
    ь
    и
    х
    у
    г
    о
    д
    ь
    я
    х
    zones_and_territories_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    з
    о
    н
    е
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    ,
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    е
    ,
    л
    е
    с
    о
    п
    а
    р
    к
    е
    ,
    о
    х
    о
    т
    н
    и
    ч
    ь
    е
    м
    у
    г
    о
    д
    ь
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, zones_and_territories_record=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 zones_and_territories_record is None:
            self.zones_and_territories_record = []
        else:
            self.zones_and_territories_record = zones_and_territories_record
        self.zones_and_territories_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ZonesAndTerritoriesBoundariesType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ZonesAndTerritoriesBoundariesType.subclass:
            return ZonesAndTerritoriesBoundariesType.subclass(*args_, **kwargs_)
        else:
            return ZonesAndTerritoriesBoundariesType(*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_zones_and_territories_record(self):
        return self.zones_and_territories_record
    def set_zones_and_territories_record(self, zones_and_territories_record):
        self.zones_and_territories_record = zones_and_territories_record
    def add_zones_and_territories_record(self, value):
        self.zones_and_territories_record.append(value)
    def insert_zones_and_territories_record_at(self, index, value):
        self.zones_and_territories_record.insert(index, value)
    def replace_zones_and_territories_record_at(self, index, value):
        self.zones_and_territories_record[index] = value
    def has__content(self):
        if (
            self.zones_and_territories_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ZonesAndTerritoriesBoundariesType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ZonesAndTerritoriesBoundariesType')
        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_ == 'ZonesAndTerritoriesBoundariesType':
            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_='ZonesAndTerritoriesBoundariesType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ZonesAndTerritoriesBoundariesType', 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_='ZonesAndTerritoriesBoundariesType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ZonesAndTerritoriesBoundariesType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for zones_and_territories_record_ in self.zones_and_territories_record:
            namespaceprefix_ = self.zones_and_territories_record_nsprefix_ + ':' if (UseCapturedNS_ and self.zones_and_territories_record_nsprefix_) else ''
            zones_and_territories_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zones_and_territories_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'zones_and_territories_record':
            obj_ = zones_and_territories_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.zones_and_territories_record.append(obj_)
            obj_.original_tagname_ = 'zones_and_territories_record'
# end class ZonesAndTerritoriesBoundariesType


class SurveyingProjectType(GeneratedsSuper):
    """SurveyingProjectType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    а
    х
    ,
    п
    о
    д
    л
    е
    ж
    а
    щ
    и
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    ю
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    н
    ы
    м
    п
    р
    о
    е
    к
    т
    о
    м
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    surveying_project_record -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    н
    о
    м
    п
    р
    о
    е
    к
    т
    е
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    и
    о
    б
    о
    б
    р
    а
    з
    у
    е
    м
    ы
    х
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    а
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, surveying_project_record=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 surveying_project_record is None:
            self.surveying_project_record = []
        else:
            self.surveying_project_record = surveying_project_record
        self.surveying_project_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SurveyingProjectType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SurveyingProjectType.subclass:
            return SurveyingProjectType.subclass(*args_, **kwargs_)
        else:
            return SurveyingProjectType(*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_surveying_project_record(self):
        return self.surveying_project_record
    def set_surveying_project_record(self, surveying_project_record):
        self.surveying_project_record = surveying_project_record
    def add_surveying_project_record(self, value):
        self.surveying_project_record.append(value)
    def insert_surveying_project_record_at(self, index, value):
        self.surveying_project_record.insert(index, value)
    def replace_surveying_project_record_at(self, index, value):
        self.surveying_project_record[index] = value
    def has__content(self):
        if (
            self.surveying_project_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SurveyingProjectType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SurveyingProjectType')
        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_ == 'SurveyingProjectType':
            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_='SurveyingProjectType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SurveyingProjectType', 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_='SurveyingProjectType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SurveyingProjectType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for surveying_project_record_ in self.surveying_project_record:
            namespaceprefix_ = self.surveying_project_record_nsprefix_ + ':' if (UseCapturedNS_ and self.surveying_project_record_nsprefix_) else ''
            surveying_project_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='surveying_project_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'surveying_project_record':
            obj_ = surveying_project_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.surveying_project_record.append(obj_)
            obj_.original_tagname_ = 'surveying_project_record'
# end class SurveyingProjectType


class ZonePermittedUses(GeneratedsSuper):
    """ZonePermittedUses -- В
    и
    д
    ы
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ,
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    т
    е
    р
    р
    и
    т
    о
    р
    и
    а
    л
    ь
    н
    о
    й
    з
    о
    н
    е
    permitted_primary_uses -- О
    с
    н
    о
    в
    н
    ы
    е
    в
    и
    д
    ы
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    permitted_conditionally_uses -- У
    с
    л
    о
    в
    н
    о
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    ы
    е
    в
    и
    д
    ы
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, permitted_primary_uses=None, permitted_conditionally_uses=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.permitted_primary_uses = permitted_primary_uses
        self.permitted_primary_uses_nsprefix_ = None
        self.permitted_conditionally_uses = permitted_conditionally_uses
        self.permitted_conditionally_uses_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ZonePermittedUses)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ZonePermittedUses.subclass:
            return ZonePermittedUses.subclass(*args_, **kwargs_)
        else:
            return ZonePermittedUses(*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_permitted_primary_uses(self):
        return self.permitted_primary_uses
    def set_permitted_primary_uses(self, permitted_primary_uses):
        self.permitted_primary_uses = permitted_primary_uses
    def get_permitted_conditionally_uses(self):
        return self.permitted_conditionally_uses
    def set_permitted_conditionally_uses(self, permitted_conditionally_uses):
        self.permitted_conditionally_uses = permitted_conditionally_uses
    def has__content(self):
        if (
            self.permitted_primary_uses is not None or
            self.permitted_conditionally_uses is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ZonePermittedUses', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ZonePermittedUses')
        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_ == 'ZonePermittedUses':
            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_='ZonePermittedUses')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ZonePermittedUses', 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_='ZonePermittedUses'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ZonePermittedUses', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.permitted_primary_uses is not None:
            namespaceprefix_ = self.permitted_primary_uses_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_primary_uses_nsprefix_) else ''
            self.permitted_primary_uses.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_primary_uses', pretty_print=pretty_print)
        if self.permitted_conditionally_uses is not None:
            namespaceprefix_ = self.permitted_conditionally_uses_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_conditionally_uses_nsprefix_) else ''
            self.permitted_conditionally_uses.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_conditionally_uses', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'permitted_primary_uses':
            obj_ = PermittedPrimaryUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_primary_uses = obj_
            obj_.original_tagname_ = 'permitted_primary_uses'
        elif nodeName_ == 'permitted_conditionally_uses':
            obj_ = PermittedConditionallyUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_conditionally_uses = obj_
            obj_.original_tagname_ = 'permitted_conditionally_uses'
# end class ZonePermittedUses


class PermittedAncillaries(GeneratedsSuper):
    """PermittedAncillaries -- В
    с
    п
    о
    м
    о
    г
    а
    т
    е
    л
    ь
    н
    ы
    е
    в
    и
    д
    ы
    permitted_ancillary -- В
    с
    п
    о
    м
    о
    г
    а
    т
    е
    л
    ь
    н
    ы
    й
    в
    и
    д
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, permitted_ancillary=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 permitted_ancillary is None:
            self.permitted_ancillary = []
        else:
            self.permitted_ancillary = permitted_ancillary
        self.permitted_ancillary_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PermittedAncillaries)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PermittedAncillaries.subclass:
            return PermittedAncillaries.subclass(*args_, **kwargs_)
        else:
            return PermittedAncillaries(*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_permitted_ancillary(self):
        return self.permitted_ancillary
    def set_permitted_ancillary(self, permitted_ancillary):
        self.permitted_ancillary = permitted_ancillary
    def add_permitted_ancillary(self, value):
        self.permitted_ancillary.append(value)
    def insert_permitted_ancillary_at(self, index, value):
        self.permitted_ancillary.insert(index, value)
    def replace_permitted_ancillary_at(self, index, value):
        self.permitted_ancillary[index] = value
    def has__content(self):
        if (
            self.permitted_ancillary
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedAncillaries', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PermittedAncillaries')
        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_ == 'PermittedAncillaries':
            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_='PermittedAncillaries')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PermittedAncillaries', 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_='PermittedAncillaries'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedAncillaries', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for permitted_ancillary_ in self.permitted_ancillary:
            namespaceprefix_ = self.permitted_ancillary_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_ancillary_nsprefix_) else ''
            permitted_ancillary_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_ancillary', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'permitted_ancillary':
            obj_ = PermittedAncillary.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_ancillary.append(obj_)
            obj_.original_tagname_ = 'permitted_ancillary'
# end class PermittedAncillaries


class PermittedAncillary(GeneratedsSuper):
    """PermittedAncillary -- В
    с
    п
    о
    м
    о
    г
    а
    т
    е
    л
    ь
    н
    ы
    й
    в
    и
    д
    permitted_use_text -- Р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    (
    т
    е
    к
    с
    т
    о
    в
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    )
    land_use -- В
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    р
    а
    н
    е
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    в
    ш
    и
    м
    с
    я
    к
    л
    а
    с
    с
    и
    ф
    и
    к
    а
    т
    о
    р
    о
    м
    land_use_mer -- В
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    к
    л
    а
    с
    с
    и
    ф
    и
    к
    а
    т
    о
    р
    о
    м
    ,
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    н
    ы
    м
    п
    р
    и
    к
    а
    з
    о
    м
    М
    и
    н
    э
    к
    о
    н
    о
    м
    р
    а
    з
    в
    и
    т
    и
    я
    Р
    о
    с
    с
    и
    и
    о
    т
    01.09.2014
    №
    540
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, permitted_use_text=None, land_use=None, land_use_mer=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.permitted_use_text = permitted_use_text
        self.validate_MultiLiner(self.permitted_use_text)
        self.permitted_use_text_nsprefix_ = None
        self.land_use = land_use
        self.land_use_nsprefix_ = None
        self.land_use_mer = land_use_mer
        self.land_use_mer_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PermittedAncillary)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PermittedAncillary.subclass:
            return PermittedAncillary.subclass(*args_, **kwargs_)
        else:
            return PermittedAncillary(*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_permitted_use_text(self):
        return self.permitted_use_text
    def set_permitted_use_text(self, permitted_use_text):
        self.permitted_use_text = permitted_use_text
    def get_land_use(self):
        return self.land_use
    def set_land_use(self, land_use):
        self.land_use = land_use
    def get_land_use_mer(self):
        return self.land_use_mer
    def set_land_use_mer(self, land_use_mer):
        self.land_use_mer = land_use_mer
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.permitted_use_text is not None or
            self.land_use is not None or
            self.land_use_mer is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedAncillary', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PermittedAncillary')
        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_ == 'PermittedAncillary':
            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_='PermittedAncillary')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PermittedAncillary', 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_='PermittedAncillary'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedAncillary', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.permitted_use_text is not None:
            namespaceprefix_ = self.permitted_use_text_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_use_text_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spermitted_use_text>%s</%spermitted_use_text>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.permitted_use_text), input_name='permitted_use_text')), namespaceprefix_ , eol_))
        if self.land_use is not None:
            namespaceprefix_ = self.land_use_nsprefix_ + ':' if (UseCapturedNS_ and self.land_use_nsprefix_) else ''
            self.land_use.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_use', pretty_print=pretty_print)
        if self.land_use_mer is not None:
            namespaceprefix_ = self.land_use_mer_nsprefix_ + ':' if (UseCapturedNS_ and self.land_use_mer_nsprefix_) else ''
            self.land_use_mer.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_use_mer', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'permitted_use_text':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'permitted_use_text')
            value_ = self.gds_validate_string(value_, node, 'permitted_use_text')
            self.permitted_use_text = value_
            self.permitted_use_text_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.permitted_use_text)
        elif nodeName_ == 'land_use':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_use = obj_
            obj_.original_tagname_ = 'land_use'
        elif nodeName_ == 'land_use_mer':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_use_mer = obj_
            obj_.original_tagname_ = 'land_use_mer'
# end class PermittedAncillary


class PermittedPrimaryUses(GeneratedsSuper):
    """PermittedPrimaryUses -- О
    с
    н
    о
    в
    н
    ы
    е
    в
    и
    д
    ы
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    permitted_primary_use -- О
    с
    н
    о
    в
    н
    о
    й
    в
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, permitted_primary_use=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 permitted_primary_use is None:
            self.permitted_primary_use = []
        else:
            self.permitted_primary_use = permitted_primary_use
        self.permitted_primary_use_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PermittedPrimaryUses)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PermittedPrimaryUses.subclass:
            return PermittedPrimaryUses.subclass(*args_, **kwargs_)
        else:
            return PermittedPrimaryUses(*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_permitted_primary_use(self):
        return self.permitted_primary_use
    def set_permitted_primary_use(self, permitted_primary_use):
        self.permitted_primary_use = permitted_primary_use
    def add_permitted_primary_use(self, value):
        self.permitted_primary_use.append(value)
    def insert_permitted_primary_use_at(self, index, value):
        self.permitted_primary_use.insert(index, value)
    def replace_permitted_primary_use_at(self, index, value):
        self.permitted_primary_use[index] = value
    def has__content(self):
        if (
            self.permitted_primary_use
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedPrimaryUses', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PermittedPrimaryUses')
        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_ == 'PermittedPrimaryUses':
            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_='PermittedPrimaryUses')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PermittedPrimaryUses', 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_='PermittedPrimaryUses'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedPrimaryUses', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for permitted_primary_use_ in self.permitted_primary_use:
            namespaceprefix_ = self.permitted_primary_use_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_primary_use_nsprefix_) else ''
            permitted_primary_use_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_primary_use', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'permitted_primary_use':
            obj_ = PermittedPrimary.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_primary_use.append(obj_)
            obj_.original_tagname_ = 'permitted_primary_use'
# end class PermittedPrimaryUses


class PermittedConditionallyUses(GeneratedsSuper):
    """PermittedConditionallyUses -- У
    с
    л
    о
    в
    н
    о
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    ы
    е
    в
    и
    д
    ы
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    permitted_conditionally_use -- У
    с
    л
    о
    в
    н
    о
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    ы
    й
    в
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, permitted_conditionally_use=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 permitted_conditionally_use is None:
            self.permitted_conditionally_use = []
        else:
            self.permitted_conditionally_use = permitted_conditionally_use
        self.permitted_conditionally_use_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PermittedConditionallyUses)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PermittedConditionallyUses.subclass:
            return PermittedConditionallyUses.subclass(*args_, **kwargs_)
        else:
            return PermittedConditionallyUses(*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_permitted_conditionally_use(self):
        return self.permitted_conditionally_use
    def set_permitted_conditionally_use(self, permitted_conditionally_use):
        self.permitted_conditionally_use = permitted_conditionally_use
    def add_permitted_conditionally_use(self, value):
        self.permitted_conditionally_use.append(value)
    def insert_permitted_conditionally_use_at(self, index, value):
        self.permitted_conditionally_use.insert(index, value)
    def replace_permitted_conditionally_use_at(self, index, value):
        self.permitted_conditionally_use[index] = value
    def has__content(self):
        if (
            self.permitted_conditionally_use
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedConditionallyUses', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PermittedConditionallyUses')
        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_ == 'PermittedConditionallyUses':
            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_='PermittedConditionallyUses')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PermittedConditionallyUses', 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_='PermittedConditionallyUses'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedConditionallyUses', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for permitted_conditionally_use_ in self.permitted_conditionally_use:
            namespaceprefix_ = self.permitted_conditionally_use_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_conditionally_use_nsprefix_) else ''
            permitted_conditionally_use_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_conditionally_use', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'permitted_conditionally_use':
            obj_ = PermittedPrimary.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_conditionally_use.append(obj_)
            obj_.original_tagname_ = 'permitted_conditionally_use'
# end class PermittedConditionallyUses


class PermittedPrimary(GeneratedsSuper):
    """PermittedPrimary -- О
    с
    н
    о
    в
    н
    о
    й
    и
    л
    и
    у
    с
    л
    о
    в
    н
    о
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    ы
    й
    в
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    permitted_use_text -- Р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    е
    (
    т
    е
    к
    с
    т
    о
    в
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    )
    land_use -- В
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    р
    а
    н
    е
    е
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    в
    ш
    и
    м
    с
    я
    к
    л
    а
    с
    с
    и
    ф
    и
    к
    а
    т
    о
    р
    о
    м
    land_use_mer -- В
    и
    д
    р
    а
    з
    р
    е
    ш
    е
    н
    н
    о
    г
    о
    и
    с
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    к
    л
    а
    с
    с
    и
    ф
    и
    к
    а
    т
    о
    р
    о
    м
    ,
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    н
    ы
    м
    п
    р
    и
    к
    а
    з
    о
    м
    М
    и
    н
    э
    к
    о
    н
    о
    м
    р
    а
    з
    в
    и
    т
    и
    я
    Р
    о
    с
    с
    и
    и
    о
    т
    01.09.2014
    №
    540
    permitted_ancillaries -- В
    с
    п
    о
    м
    о
    г
    а
    т
    е
    л
    ь
    н
    ы
    е
    в
    и
    д
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, permitted_use_text=None, land_use=None, land_use_mer=None, permitted_ancillaries=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.permitted_use_text = permitted_use_text
        self.validate_MultiLiner(self.permitted_use_text)
        self.permitted_use_text_nsprefix_ = None
        self.land_use = land_use
        self.land_use_nsprefix_ = None
        self.land_use_mer = land_use_mer
        self.land_use_mer_nsprefix_ = None
        self.permitted_ancillaries = permitted_ancillaries
        self.permitted_ancillaries_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PermittedPrimary)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PermittedPrimary.subclass:
            return PermittedPrimary.subclass(*args_, **kwargs_)
        else:
            return PermittedPrimary(*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_permitted_use_text(self):
        return self.permitted_use_text
    def set_permitted_use_text(self, permitted_use_text):
        self.permitted_use_text = permitted_use_text
    def get_land_use(self):
        return self.land_use
    def set_land_use(self, land_use):
        self.land_use = land_use
    def get_land_use_mer(self):
        return self.land_use_mer
    def set_land_use_mer(self, land_use_mer):
        self.land_use_mer = land_use_mer
    def get_permitted_ancillaries(self):
        return self.permitted_ancillaries
    def set_permitted_ancillaries(self, permitted_ancillaries):
        self.permitted_ancillaries = permitted_ancillaries
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.permitted_use_text is not None or
            self.land_use is not None or
            self.land_use_mer is not None or
            self.permitted_ancillaries is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedPrimary', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PermittedPrimary')
        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_ == 'PermittedPrimary':
            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_='PermittedPrimary')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PermittedPrimary', 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_='PermittedPrimary'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PermittedPrimary', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.permitted_use_text is not None:
            namespaceprefix_ = self.permitted_use_text_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_use_text_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spermitted_use_text>%s</%spermitted_use_text>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.permitted_use_text), input_name='permitted_use_text')), namespaceprefix_ , eol_))
        if self.land_use is not None:
            namespaceprefix_ = self.land_use_nsprefix_ + ':' if (UseCapturedNS_ and self.land_use_nsprefix_) else ''
            self.land_use.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_use', pretty_print=pretty_print)
        if self.land_use_mer is not None:
            namespaceprefix_ = self.land_use_mer_nsprefix_ + ':' if (UseCapturedNS_ and self.land_use_mer_nsprefix_) else ''
            self.land_use_mer.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_use_mer', pretty_print=pretty_print)
        if self.permitted_ancillaries is not None:
            namespaceprefix_ = self.permitted_ancillaries_nsprefix_ + ':' if (UseCapturedNS_ and self.permitted_ancillaries_nsprefix_) else ''
            self.permitted_ancillaries.export(outfile, level, namespaceprefix_, namespacedef_='', name_='permitted_ancillaries', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'permitted_use_text':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'permitted_use_text')
            value_ = self.gds_validate_string(value_, node, 'permitted_use_text')
            self.permitted_use_text = value_
            self.permitted_use_text_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.permitted_use_text)
        elif nodeName_ == 'land_use':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_use = obj_
            obj_.original_tagname_ = 'land_use'
        elif nodeName_ == 'land_use_mer':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_use_mer = obj_
            obj_.original_tagname_ = 'land_use_mer'
        elif nodeName_ == 'permitted_ancillaries':
            obj_ = PermittedAncillaries.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.permitted_ancillaries = obj_
            obj_.original_tagname_ = 'permitted_ancillaries'
# end class PermittedPrimary


class IncludedParcels(GeneratedsSuper):
    """IncludedParcels -- П
    е
    р
    е
    ч
    е
    н
    ь
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ,
    п
    о
    л
    н
    о
    с
    т
    ь
    ю
    и
    л
    и
    ч
    а
    с
    т
    и
    ч
    н
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    з
    о
    н
    ы
    и
    л
    и
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    includ_parcel -- З
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, includ_parcel=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 includ_parcel is None:
            self.includ_parcel = []
        else:
            self.includ_parcel = includ_parcel
        self.includ_parcel_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IncludedParcels)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IncludedParcels.subclass:
            return IncludedParcels.subclass(*args_, **kwargs_)
        else:
            return IncludedParcels(*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_includ_parcel(self):
        return self.includ_parcel
    def set_includ_parcel(self, includ_parcel):
        self.includ_parcel = includ_parcel
    def add_includ_parcel(self, value):
        self.includ_parcel.append(value)
    def insert_includ_parcel_at(self, index, value):
        self.includ_parcel.insert(index, value)
    def replace_includ_parcel_at(self, index, value):
        self.includ_parcel[index] = value
    def has__content(self):
        if (
            self.includ_parcel
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncludedParcels', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IncludedParcels')
        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_ == 'IncludedParcels':
            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_='IncludedParcels')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IncludedParcels', 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_='IncludedParcels'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncludedParcels', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for includ_parcel_ in self.includ_parcel:
            namespaceprefix_ = self.includ_parcel_nsprefix_ + ':' if (UseCapturedNS_ and self.includ_parcel_nsprefix_) else ''
            includ_parcel_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='includ_parcel', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'includ_parcel':
            obj_ = IncludedParcelsInZone.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.includ_parcel.append(obj_)
            obj_.original_tagname_ = 'includ_parcel'
# end class IncludedParcels


class IncludedParcelsInZone(GeneratedsSuper):
    """IncludedParcelsInZone -- С
    в
    е
    д
    е
    н
    и
    я
    о
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    а
    х
    ,
    п
    о
    л
    н
    о
    с
    т
    ь
    ю
    и
    л
    и
    ч
    а
    с
    т
    и
    ч
    н
    о
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    н
    ы
    х
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    з
    о
    н
    ы
    и
    л
    и
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    object_part -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cad_number=None, object_part=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.cad_number = cad_number
        self.cad_number_nsprefix_ = None
        self.object_part = object_part
        self.object_part_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IncludedParcelsInZone)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IncludedParcelsInZone.subclass:
            return IncludedParcelsInZone.subclass(*args_, **kwargs_)
        else:
            return IncludedParcelsInZone(*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_cad_number(self):
        return self.cad_number
    def set_cad_number(self, cad_number):
        self.cad_number = cad_number
    def get_object_part(self):
        return self.object_part
    def set_object_part(self, object_part):
        self.object_part = object_part
    def has__content(self):
        if (
            self.cad_number is not None or
            self.object_part is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncludedParcelsInZone', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IncludedParcelsInZone')
        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_ == 'IncludedParcelsInZone':
            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_='IncludedParcelsInZone')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IncludedParcelsInZone', 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_='IncludedParcelsInZone'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IncludedParcelsInZone', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.cad_number is not None:
            namespaceprefix_ = self.cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scad_number>%s</%scad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cad_number), input_name='cad_number')), namespaceprefix_ , eol_))
        if self.object_part is not None:
            namespaceprefix_ = self.object_part_nsprefix_ + ':' if (UseCapturedNS_ and self.object_part_nsprefix_) else ''
            self.object_part.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_part', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cad_number')
            value_ = self.gds_validate_string(value_, node, 'cad_number')
            self.cad_number = value_
            self.cad_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'object_part':
            obj_ = ObjectPartNumberDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_part = obj_
            obj_.original_tagname_ = 'object_part'
# end class IncludedParcelsInZone


class Fio(GeneratedsSuper):
    """Fio -- Ф
    И
    О
      
    * surname -- Ф
      а
      м
      и
      л
      и
      я
    * name -- И
      м
      я
    * patronymic -- О
      т
      ч
      е
      с
      т
      в
      о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, surname=None, name=None, patronymic=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.surname = surname
        self.surname_nsprefix_ = None
        self.name = name
        self.name_nsprefix_ = None
        self.patronymic = patronymic
        self.patronymic_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Fio)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Fio.subclass:
            return Fio.subclass(*args_, **kwargs_)
        else:
            return Fio(*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_surname(self):
        return self.surname
    def set_surname(self, surname):
        self.surname = surname
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_patronymic(self):
        return self.patronymic
    def set_patronymic(self, patronymic):
        self.patronymic = patronymic
    def has__content(self):
        if (
            self.surname is not None or
            self.name is not None or
            self.patronymic is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Fio', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Fio')
        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_ == 'Fio':
            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_='Fio')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Fio', 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_='Fio'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Fio', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            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.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.patronymic is not None:
            namespaceprefix_ = self.patronymic_nsprefix_ + ':' if (UseCapturedNS_ and self.patronymic_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spatronymic>%s</%spatronymic>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.patronymic), input_name='patronymic')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if 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_ == '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_ == 'patronymic':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'patronymic')
            value_ = self.gds_validate_string(value_, node, 'patronymic')
            self.patronymic = value_
            self.patronymic_nsprefix_ = child_.prefix
# end class Fio


class CadNumber(GeneratedsSuper):
    """CadNumber -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, cad_number=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.cad_number = cad_number
        self.cad_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CadNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CadNumber.subclass:
            return CadNumber.subclass(*args_, **kwargs_)
        else:
            return CadNumber(*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_cad_number(self):
        return self.cad_number
    def set_cad_number(self, cad_number):
        self.cad_number = cad_number
    def has__content(self):
        if (
            self.cad_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CadNumber')
        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_ == 'CadNumber':
            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_='CadNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CadNumber', 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_='CadNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CadNumber', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.cad_number is not None:
            namespaceprefix_ = self.cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scad_number>%s</%scad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cad_number), input_name='cad_number')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cad_number')
            value_ = self.gds_validate_string(value_, node, 'cad_number')
            self.cad_number = value_
            self.cad_number_nsprefix_ = child_.prefix
# end class CadNumber


class BaseParameters(GeneratedsSuper):
    """BaseParameters -- О
    с
    н
    о
    в
    н
    ы
    е
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    base_parameter -- О
    с
    н
    о
    в
    н
    а
    я
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, base_parameter=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 base_parameter is None:
            self.base_parameter = []
        else:
            self.base_parameter = base_parameter
        self.base_parameter_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BaseParameters)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BaseParameters.subclass:
            return BaseParameters.subclass(*args_, **kwargs_)
        else:
            return BaseParameters(*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_base_parameter(self):
        return self.base_parameter
    def set_base_parameter(self, base_parameter):
        self.base_parameter = base_parameter
    def add_base_parameter(self, value):
        self.base_parameter.append(value)
    def insert_base_parameter_at(self, index, value):
        self.base_parameter.insert(index, value)
    def replace_base_parameter_at(self, index, value):
        self.base_parameter[index] = value
    def has__content(self):
        if (
            self.base_parameter
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BaseParameters', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BaseParameters')
        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_ == 'BaseParameters':
            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_='BaseParameters')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BaseParameters', 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_='BaseParameters'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BaseParameters', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for base_parameter_ in self.base_parameter:
            namespaceprefix_ = self.base_parameter_nsprefix_ + ':' if (UseCapturedNS_ and self.base_parameter_nsprefix_) else ''
            base_parameter_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='base_parameter', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'base_parameter':
            obj_ = base_parameterType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.base_parameter.append(obj_)
            obj_.original_tagname_ = 'base_parameter'
# end class BaseParameters


class RightHoldersOut(GeneratedsSuper):
    """RightHoldersOut -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    right_holder -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_holder=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 right_holder is None:
            self.right_holder = []
        else:
            self.right_holder = right_holder
        self.right_holder_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightHoldersOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightHoldersOut.subclass:
            return RightHoldersOut.subclass(*args_, **kwargs_)
        else:
            return RightHoldersOut(*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_right_holder(self):
        return self.right_holder
    def set_right_holder(self, right_holder):
        self.right_holder = right_holder
    def add_right_holder(self, value):
        self.right_holder.append(value)
    def insert_right_holder_at(self, index, value):
        self.right_holder.insert(index, value)
    def replace_right_holder_at(self, index, value):
        self.right_holder[index] = value
    def has__content(self):
        if (
            self.right_holder
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightHoldersOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightHoldersOut')
        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_ == 'RightHoldersOut':
            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_='RightHoldersOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightHoldersOut', 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_='RightHoldersOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightHoldersOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for right_holder_ in self.right_holder:
            namespaceprefix_ = self.right_holder_nsprefix_ + ':' if (UseCapturedNS_ and self.right_holder_nsprefix_) else ''
            right_holder_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_holder', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_holder':
            obj_ = RightHolderOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_holder.append(obj_)
            obj_.original_tagname_ = 'right_holder'
# end class RightHoldersOut


class RightHolderOut(GeneratedsSuper):
    """RightHolderOut -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    е
    public_formation -- П
    у
    б
    л
    и
    ч
    н
    о
    -
    п
    р
    а
    в
    о
    в
    о
    е
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    е
    individual -- Ф
    и
    з
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    legal_entity -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    ,
    о
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    another -- И
    н
    о
    й
    с
    у
    б
    ъ
    е
    к
    т
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, public_formation=None, individual=None, legal_entity=None, another=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.public_formation = public_formation
        self.public_formation_nsprefix_ = None
        self.individual = individual
        self.individual_nsprefix_ = None
        self.legal_entity = legal_entity
        self.legal_entity_nsprefix_ = None
        self.another = another
        self.another_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightHolderOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightHolderOut.subclass:
            return RightHolderOut.subclass(*args_, **kwargs_)
        else:
            return RightHolderOut(*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_public_formation(self):
        return self.public_formation
    def set_public_formation(self, public_formation):
        self.public_formation = public_formation
    def get_individual(self):
        return self.individual
    def set_individual(self, individual):
        self.individual = individual
    def get_legal_entity(self):
        return self.legal_entity
    def set_legal_entity(self, legal_entity):
        self.legal_entity = legal_entity
    def get_another(self):
        return self.another
    def set_another(self, another):
        self.another = another
    def has__content(self):
        if (
            self.public_formation is not None or
            self.individual is not None or
            self.legal_entity is not None or
            self.another is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightHolderOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightHolderOut')
        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_ == 'RightHolderOut':
            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_='RightHolderOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightHolderOut', 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_='RightHolderOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightHolderOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.public_formation is not None:
            namespaceprefix_ = self.public_formation_nsprefix_ + ':' if (UseCapturedNS_ and self.public_formation_nsprefix_) else ''
            self.public_formation.export(outfile, level, namespaceprefix_, namespacedef_='', name_='public_formation', pretty_print=pretty_print)
        if self.individual is not None:
            namespaceprefix_ = self.individual_nsprefix_ + ':' if (UseCapturedNS_ and self.individual_nsprefix_) else ''
            self.individual.export(outfile, level, namespaceprefix_, namespacedef_='', name_='individual', pretty_print=pretty_print)
        if self.legal_entity is not None:
            namespaceprefix_ = self.legal_entity_nsprefix_ + ':' if (UseCapturedNS_ and self.legal_entity_nsprefix_) else ''
            self.legal_entity.export(outfile, level, namespaceprefix_, namespacedef_='', name_='legal_entity', pretty_print=pretty_print)
        if self.another is not None:
            namespaceprefix_ = self.another_nsprefix_ + ':' if (UseCapturedNS_ and self.another_nsprefix_) else ''
            self.another.export(outfile, level, namespaceprefix_, namespacedef_='', name_='another', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'public_formation':
            obj_ = PublicFormations.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.public_formation = obj_
            obj_.original_tagname_ = 'public_formation'
        elif nodeName_ == 'individual':
            obj_ = IndividualOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.individual = obj_
            obj_.original_tagname_ = 'individual'
        elif nodeName_ == 'legal_entity':
            obj_ = LegalEntityOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.legal_entity = obj_
            obj_.original_tagname_ = 'legal_entity'
        elif nodeName_ == 'another':
            obj_ = AnotherRight.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.another = obj_
            obj_.original_tagname_ = 'another'
# end class RightHolderOut


class AnotherRight(GeneratedsSuper):
    """AnotherRight -- И
    н
    о
    й
    с
    у
    б
    ъ
    е
    к
    т
    п
    р
    а
    в
    а
    another_type -- Т
    и
    п
    и
    н
    о
    г
    о
    с
    у
    б
    ъ
    е
    к
    т
    а
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, another_type=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.another_type = another_type
        self.another_type_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AnotherRight)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AnotherRight.subclass:
            return AnotherRight.subclass(*args_, **kwargs_)
        else:
            return AnotherRight(*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_another_type(self):
        return self.another_type
    def set_another_type(self, another_type):
        self.another_type = another_type
    def has__content(self):
        if (
            self.another_type is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherRight', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AnotherRight')
        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_ == 'AnotherRight':
            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_='AnotherRight')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AnotherRight', 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_='AnotherRight'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherRight', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.another_type is not None:
            namespaceprefix_ = self.another_type_nsprefix_ + ':' if (UseCapturedNS_ and self.another_type_nsprefix_) else ''
            self.another_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='another_type', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'another_type':
            obj_ = AnotherTypeRight.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.another_type = obj_
            obj_.original_tagname_ = 'another_type'
# end class AnotherRight


class AnotherTypeRight(GeneratedsSuper):
    """AnotherTypeRight -- Т
    и
    п
    и
    н
    о
    г
    о
    с
    у
    б
    ъ
    е
    к
    т
    а
    п
    р
    а
    в
    а
    investment_unit_owner -- В
    л
    а
    д
    е
    л
    ь
    ц
    ы
    и
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    ы
    х
    п
    а
    е
    в
    certificates_holders -- В
    л
    а
    д
    е
    л
    ь
    ц
    ы
    и
    п
    о
    т
    е
    ч
    н
    ы
    х
    с
    е
    р
    т
    и
    ф
    и
    к
    а
    т
    о
    в
    у
    ч
    а
    с
    т
    и
    я
    bonds_holders -- В
    л
    а
    д
    е
    л
    ь
    ц
    ы
    о
    б
    л
    и
    г
    а
    ц
    и
    й
    partnership -- И
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    о
    е
    т
    о
    в
    а
    р
    и
    щ
    е
    с
    т
    в
    о
    aparthouse_owners -- С
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    в
    м
    н
    о
    г
    о
    к
    в
    а
    р
    т
    и
    р
    н
    о
    м
    д
    о
    м
    е
    other -- И
    н
    о
    й
    с
    у
    б
    ъ
    е
    к
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, investment_unit_owner=None, certificates_holders=None, bonds_holders=None, partnership=None, aparthouse_owners=None, other=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.investment_unit_owner = investment_unit_owner
        self.investment_unit_owner_nsprefix_ = None
        self.certificates_holders = certificates_holders
        self.certificates_holders_nsprefix_ = None
        self.bonds_holders = bonds_holders
        self.bonds_holders_nsprefix_ = None
        self.partnership = partnership
        self.partnership_nsprefix_ = None
        self.aparthouse_owners = aparthouse_owners
        self.aparthouse_owners_nsprefix_ = None
        self.other = other
        self.other_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AnotherTypeRight)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AnotherTypeRight.subclass:
            return AnotherTypeRight.subclass(*args_, **kwargs_)
        else:
            return AnotherTypeRight(*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_investment_unit_owner(self):
        return self.investment_unit_owner
    def set_investment_unit_owner(self, investment_unit_owner):
        self.investment_unit_owner = investment_unit_owner
    def get_certificates_holders(self):
        return self.certificates_holders
    def set_certificates_holders(self, certificates_holders):
        self.certificates_holders = certificates_holders
    def get_bonds_holders(self):
        return self.bonds_holders
    def set_bonds_holders(self, bonds_holders):
        self.bonds_holders = bonds_holders
    def get_partnership(self):
        return self.partnership
    def set_partnership(self, partnership):
        self.partnership = partnership
    def get_aparthouse_owners(self):
        return self.aparthouse_owners
    def set_aparthouse_owners(self, aparthouse_owners):
        self.aparthouse_owners = aparthouse_owners
    def get_other(self):
        return self.other
    def set_other(self, other):
        self.other = other
    def has__content(self):
        if (
            self.investment_unit_owner is not None or
            self.certificates_holders is not None or
            self.bonds_holders is not None or
            self.partnership is not None or
            self.aparthouse_owners is not None or
            self.other is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherTypeRight', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AnotherTypeRight')
        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_ == 'AnotherTypeRight':
            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_='AnotherTypeRight')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AnotherTypeRight', 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_='AnotherTypeRight'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherTypeRight', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.investment_unit_owner is not None:
            namespaceprefix_ = self.investment_unit_owner_nsprefix_ + ':' if (UseCapturedNS_ and self.investment_unit_owner_nsprefix_) else ''
            self.investment_unit_owner.export(outfile, level, namespaceprefix_, namespacedef_='', name_='investment_unit_owner', pretty_print=pretty_print)
        if self.certificates_holders is not None:
            namespaceprefix_ = self.certificates_holders_nsprefix_ + ':' if (UseCapturedNS_ and self.certificates_holders_nsprefix_) else ''
            self.certificates_holders.export(outfile, level, namespaceprefix_, namespacedef_='', name_='certificates_holders', pretty_print=pretty_print)
        if self.bonds_holders is not None:
            namespaceprefix_ = self.bonds_holders_nsprefix_ + ':' if (UseCapturedNS_ and self.bonds_holders_nsprefix_) else ''
            self.bonds_holders.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bonds_holders', pretty_print=pretty_print)
        if self.partnership is not None:
            namespaceprefix_ = self.partnership_nsprefix_ + ':' if (UseCapturedNS_ and self.partnership_nsprefix_) else ''
            self.partnership.export(outfile, level, namespaceprefix_, namespacedef_='', name_='partnership', pretty_print=pretty_print)
        if self.aparthouse_owners is not None:
            namespaceprefix_ = self.aparthouse_owners_nsprefix_ + ':' if (UseCapturedNS_ and self.aparthouse_owners_nsprefix_) else ''
            self.aparthouse_owners.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aparthouse_owners', pretty_print=pretty_print)
        if self.other is not None:
            namespaceprefix_ = self.other_nsprefix_ + ':' if (UseCapturedNS_ and self.other_nsprefix_) else ''
            self.other.export(outfile, level, namespaceprefix_, namespacedef_='', name_='other', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'investment_unit_owner':
            obj_ = InvestmentUnitOwnerOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.investment_unit_owner = obj_
            obj_.original_tagname_ = 'investment_unit_owner'
        elif nodeName_ == 'certificates_holders':
            obj_ = CertificatesHoldersOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.certificates_holders = obj_
            obj_.original_tagname_ = 'certificates_holders'
        elif nodeName_ == 'bonds_holders':
            obj_ = BondsHoldersOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.bonds_holders = obj_
            obj_.original_tagname_ = 'bonds_holders'
        elif nodeName_ == 'partnership':
            obj_ = Partnership.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.partnership = obj_
            obj_.original_tagname_ = 'partnership'
        elif nodeName_ == 'aparthouse_owners':
            obj_ = AparthouseOwners.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.aparthouse_owners = obj_
            obj_.original_tagname_ = 'aparthouse_owners'
        elif nodeName_ == 'other':
            obj_ = OtherSubject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.other = obj_
            obj_.original_tagname_ = 'other'
# end class AnotherTypeRight


class PersonDocument(GeneratedsSuper):
    """PersonDocument -- Д
    о
    к
    у
    м
    е
    н
    т
    ,
    у
    д
    о
    с
    т
    о
    в
    е
    р
    я
    ю
    щ
    и
    й
    л
    и
    ч
    н
    о
    с
    т
    ь
    document_code -- К
    о
    д
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    document_series -- С
    е
    р
    и
    я
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_number --
    Н
    о
    м
    е
    р
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_date -- Д
    а
    т
    а
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_issuer -- К
    е
    м
    в
    ы
    д
    а
    н
    (
    О
    р
    г
    а
    н
    и
    з
    а
    ц
    и
    я
    ,
    в
    ы
    д
    а
    в
    ш
    а
    я
    д
    о
    к
    у
    м
    е
    н
    т
    )
    special_marks -- О
    с
    о
    б
    ы
    е
    о
    т
    м
    е
    т
    к
    и
    doc_notarized -- Н
    о
    т
    а
    р
    и
    а
    л
    ь
    н
    о
    е
    у
    д
    о
    с
    т
    о
    в
    е
    р
    е
    н
    и
    е
    д
    о
    к
    у
    м
    е
    н
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, document_code=None, document_name=None, document_series=None, document_number=None, document_date=None, document_issuer=None, special_marks=None, doc_notarized=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.document_code = document_code
        self.document_code_nsprefix_ = None
        self.document_name = document_name
        self.document_name_nsprefix_ = None
        self.document_series = document_series
        self.document_series_nsprefix_ = None
        self.document_number = document_number
        self.document_number_nsprefix_ = None
        if isinstance(document_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(document_date, '%Y-%m-%d').date()
        else:
            initvalue_ = document_date
        self.document_date = initvalue_
        self.document_date_nsprefix_ = None
        self.document_issuer = document_issuer
        self.validate_MultiLiner(self.document_issuer)
        self.document_issuer_nsprefix_ = None
        self.special_marks = special_marks
        self.validate_MultiLiner(self.special_marks)
        self.special_marks_nsprefix_ = None
        self.doc_notarized = doc_notarized
        self.doc_notarized_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PersonDocument)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PersonDocument.subclass:
            return PersonDocument.subclass(*args_, **kwargs_)
        else:
            return PersonDocument(*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_document_code(self):
        return self.document_code
    def set_document_code(self, document_code):
        self.document_code = document_code
    def get_document_name(self):
        return self.document_name
    def set_document_name(self, document_name):
        self.document_name = document_name
    def get_document_series(self):
        return self.document_series
    def set_document_series(self, document_series):
        self.document_series = document_series
    def get_document_number(self):
        return self.document_number
    def set_document_number(self, document_number):
        self.document_number = document_number
    def get_document_date(self):
        return self.document_date
    def set_document_date(self, document_date):
        self.document_date = document_date
    def get_document_issuer(self):
        return self.document_issuer
    def set_document_issuer(self, document_issuer):
        self.document_issuer = document_issuer
    def get_special_marks(self):
        return self.special_marks
    def set_special_marks(self, special_marks):
        self.special_marks = special_marks
    def get_doc_notarized(self):
        return self.doc_notarized
    def set_doc_notarized(self, doc_notarized):
        self.doc_notarized = doc_notarized
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.document_code is not None or
            self.document_name is not None or
            self.document_series is not None or
            self.document_number is not None or
            self.document_date is not None or
            self.document_issuer is not None or
            self.special_marks is not None or
            self.doc_notarized is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PersonDocument', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PersonDocument')
        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_ == 'PersonDocument':
            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_='PersonDocument')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PersonDocument', 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_='PersonDocument'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PersonDocument', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.document_code is not None:
            namespaceprefix_ = self.document_code_nsprefix_ + ':' if (UseCapturedNS_ and self.document_code_nsprefix_) else ''
            self.document_code.export(outfile, level, namespaceprefix_, namespacedef_='', name_='document_code', pretty_print=pretty_print)
        if self.document_name is not None:
            namespaceprefix_ = self.document_name_nsprefix_ + ':' if (UseCapturedNS_ and self.document_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_name>%s</%sdocument_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_name), input_name='document_name')), namespaceprefix_ , eol_))
        if self.document_series is not None:
            namespaceprefix_ = self.document_series_nsprefix_ + ':' if (UseCapturedNS_ and self.document_series_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_series>%s</%sdocument_series>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_series), input_name='document_series')), namespaceprefix_ , eol_))
        if self.document_number is not None:
            namespaceprefix_ = self.document_number_nsprefix_ + ':' if (UseCapturedNS_ and self.document_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_number>%s</%sdocument_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_number), input_name='document_number')), namespaceprefix_ , eol_))
        if self.document_date is not None:
            namespaceprefix_ = self.document_date_nsprefix_ + ':' if (UseCapturedNS_ and self.document_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_date>%s</%sdocument_date>%s' % (namespaceprefix_ , self.gds_format_date(self.document_date, input_name='document_date'), namespaceprefix_ , eol_))
        if self.document_issuer is not None:
            namespaceprefix_ = self.document_issuer_nsprefix_ + ':' if (UseCapturedNS_ and self.document_issuer_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_issuer>%s</%sdocument_issuer>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_issuer), input_name='document_issuer')), namespaceprefix_ , eol_))
        if self.special_marks is not None:
            namespaceprefix_ = self.special_marks_nsprefix_ + ':' if (UseCapturedNS_ and self.special_marks_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sspecial_marks>%s</%sspecial_marks>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.special_marks), input_name='special_marks')), namespaceprefix_ , eol_))
        if self.doc_notarized is not None:
            namespaceprefix_ = self.doc_notarized_nsprefix_ + ':' if (UseCapturedNS_ and self.doc_notarized_nsprefix_) else ''
            self.doc_notarized.export(outfile, level, namespaceprefix_, namespacedef_='', name_='doc_notarized', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'document_code':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.document_code = obj_
            obj_.original_tagname_ = 'document_code'
        elif nodeName_ == 'document_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_name')
            value_ = self.gds_validate_string(value_, node, 'document_name')
            self.document_name = value_
            self.document_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_series':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_series')
            value_ = self.gds_validate_string(value_, node, 'document_series')
            self.document_series = value_
            self.document_series_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_number')
            value_ = self.gds_validate_string(value_, node, 'document_number')
            self.document_number = value_
            self.document_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.document_date = dval_
            self.document_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_issuer':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_issuer')
            value_ = self.gds_validate_string(value_, node, 'document_issuer')
            self.document_issuer = value_
            self.document_issuer_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.document_issuer)
        elif nodeName_ == 'special_marks':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'special_marks')
            value_ = self.gds_validate_string(value_, node, 'special_marks')
            self.special_marks = value_
            self.special_marks_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.special_marks)
        elif nodeName_ == 'doc_notarized':
            obj_ = DocNotarized.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.doc_notarized = obj_
            obj_.original_tagname_ = 'doc_notarized'
# end class PersonDocument


class RestrictParties(GeneratedsSuper):
    """RestrictParties -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    а
    х
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restricted_rights_parties -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    а
    х
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restricted_rights_parties=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.restricted_rights_parties = restricted_rights_parties
        self.restricted_rights_parties_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictParties)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictParties.subclass:
            return RestrictParties.subclass(*args_, **kwargs_)
        else:
            return RestrictParties(*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_restricted_rights_parties(self):
        return self.restricted_rights_parties
    def set_restricted_rights_parties(self, restricted_rights_parties):
        self.restricted_rights_parties = restricted_rights_parties
    def has__content(self):
        if (
            self.restricted_rights_parties is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictParties', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictParties')
        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_ == 'RestrictParties':
            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_='RestrictParties')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictParties', 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_='RestrictParties'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictParties', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.restricted_rights_parties is not None:
            namespaceprefix_ = self.restricted_rights_parties_nsprefix_ + ':' if (UseCapturedNS_ and self.restricted_rights_parties_nsprefix_) else ''
            self.restricted_rights_parties.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restricted_rights_parties', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restricted_rights_parties':
            obj_ = RestrictedRightsPartiesOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restricted_rights_parties = obj_
            obj_.original_tagname_ = 'restricted_rights_parties'
# end class RestrictParties


class RestrictedRightsPartiesOut(GeneratedsSuper):
    """RestrictedRightsPartiesOut -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    а
    х
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restricted_rights_party -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    е
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    о
    г
    о
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restricted_rights_party=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 restricted_rights_party is None:
            self.restricted_rights_party = []
        else:
            self.restricted_rights_party = restricted_rights_party
        self.restricted_rights_party_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictedRightsPartiesOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictedRightsPartiesOut.subclass:
            return RestrictedRightsPartiesOut.subclass(*args_, **kwargs_)
        else:
            return RestrictedRightsPartiesOut(*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_restricted_rights_party(self):
        return self.restricted_rights_party
    def set_restricted_rights_party(self, restricted_rights_party):
        self.restricted_rights_party = restricted_rights_party
    def add_restricted_rights_party(self, value):
        self.restricted_rights_party.append(value)
    def insert_restricted_rights_party_at(self, index, value):
        self.restricted_rights_party.insert(index, value)
    def replace_restricted_rights_party_at(self, index, value):
        self.restricted_rights_party[index] = value
    def has__content(self):
        if (
            self.restricted_rights_party
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictedRightsPartiesOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictedRightsPartiesOut')
        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_ == 'RestrictedRightsPartiesOut':
            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_='RestrictedRightsPartiesOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictedRightsPartiesOut', 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_='RestrictedRightsPartiesOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictedRightsPartiesOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for restricted_rights_party_ in self.restricted_rights_party:
            namespaceprefix_ = self.restricted_rights_party_nsprefix_ + ':' if (UseCapturedNS_ and self.restricted_rights_party_nsprefix_) else ''
            restricted_rights_party_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restricted_rights_party', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restricted_rights_party':
            obj_ = RestrictedRightsPartyOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restricted_rights_party.append(obj_)
            obj_.original_tagname_ = 'restricted_rights_party'
# end class RestrictedRightsPartiesOut


class RestrictedRightsPartyOut(GeneratedsSuper):
    """RestrictedRightsPartyOut -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    е
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    о
    г
    о
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    type -- Т
    и
    п
    л
    и
    ц
    а
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    subject -- Л
    и
    ц
    о
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    о
    г
    о
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_=None, subject=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.type_ = type_
        self.type__nsprefix_ = None
        self.subject = subject
        self.subject_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictedRightsPartyOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictedRightsPartyOut.subclass:
            return RestrictedRightsPartyOut.subclass(*args_, **kwargs_)
        else:
            return RestrictedRightsPartyOut(*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_type(self):
        return self.type_
    def set_type(self, type_):
        self.type_ = type_
    def get_subject(self):
        return self.subject
    def set_subject(self, subject):
        self.subject = subject
    def has__content(self):
        if (
            self.type_ is not None or
            self.subject is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictedRightsPartyOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictedRightsPartyOut')
        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_ == 'RestrictedRightsPartyOut':
            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_='RestrictedRightsPartyOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictedRightsPartyOut', 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_='RestrictedRightsPartyOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictedRightsPartyOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_ is not None:
            namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else ''
            self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', pretty_print=pretty_print)
        if self.subject is not None:
            namespaceprefix_ = self.subject_nsprefix_ + ':' if (UseCapturedNS_ and self.subject_nsprefix_) else ''
            self.subject.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subject', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
        elif nodeName_ == 'subject':
            obj_ = SubjectRestricted.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.subject = obj_
            obj_.original_tagname_ = 'subject'
# end class RestrictedRightsPartyOut


class SubjectRestricted(GeneratedsSuper):
    """SubjectRestricted -- Л
    и
    ц
    о
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    о
    г
    о
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    public_formation -- П
    у
    б
    л
    и
    ч
    н
    о
    -
    п
    р
    а
    в
    о
    в
    о
    е
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    е
    individual -- Ф
    и
    з
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    legal_entity -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    ,
    о
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    another -- И
    н
    о
    е
    л
    и
    ц
    о
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    о
    г
    о
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    public_servitude -- П
    у
    б
    л
    и
    ч
    н
    ы
    й
    с
    е
    р
    в
    и
    т
    у
    т
    undefined -- Н
    е
    о
    п
    р
    е
    д
    е
    л
    е
    н
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, public_formation=None, individual=None, legal_entity=None, another=None, public_servitude=None, undefined=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.public_formation = public_formation
        self.public_formation_nsprefix_ = None
        self.individual = individual
        self.individual_nsprefix_ = None
        self.legal_entity = legal_entity
        self.legal_entity_nsprefix_ = None
        self.another = another
        self.another_nsprefix_ = None
        self.public_servitude = public_servitude
        self.public_servitude_nsprefix_ = None
        self.undefined = undefined
        self.undefined_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SubjectRestricted)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SubjectRestricted.subclass:
            return SubjectRestricted.subclass(*args_, **kwargs_)
        else:
            return SubjectRestricted(*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_public_formation(self):
        return self.public_formation
    def set_public_formation(self, public_formation):
        self.public_formation = public_formation
    def get_individual(self):
        return self.individual
    def set_individual(self, individual):
        self.individual = individual
    def get_legal_entity(self):
        return self.legal_entity
    def set_legal_entity(self, legal_entity):
        self.legal_entity = legal_entity
    def get_another(self):
        return self.another
    def set_another(self, another):
        self.another = another
    def get_public_servitude(self):
        return self.public_servitude
    def set_public_servitude(self, public_servitude):
        self.public_servitude = public_servitude
    def get_undefined(self):
        return self.undefined
    def set_undefined(self, undefined):
        self.undefined = undefined
    def has__content(self):
        if (
            self.public_formation is not None or
            self.individual is not None or
            self.legal_entity is not None or
            self.another is not None or
            self.public_servitude is not None or
            self.undefined is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SubjectRestricted', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SubjectRestricted')
        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_ == 'SubjectRestricted':
            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_='SubjectRestricted')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SubjectRestricted', 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_='SubjectRestricted'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SubjectRestricted', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.public_formation is not None:
            namespaceprefix_ = self.public_formation_nsprefix_ + ':' if (UseCapturedNS_ and self.public_formation_nsprefix_) else ''
            self.public_formation.export(outfile, level, namespaceprefix_, namespacedef_='', name_='public_formation', pretty_print=pretty_print)
        if self.individual is not None:
            namespaceprefix_ = self.individual_nsprefix_ + ':' if (UseCapturedNS_ and self.individual_nsprefix_) else ''
            self.individual.export(outfile, level, namespaceprefix_, namespacedef_='', name_='individual', pretty_print=pretty_print)
        if self.legal_entity is not None:
            namespaceprefix_ = self.legal_entity_nsprefix_ + ':' if (UseCapturedNS_ and self.legal_entity_nsprefix_) else ''
            self.legal_entity.export(outfile, level, namespaceprefix_, namespacedef_='', name_='legal_entity', pretty_print=pretty_print)
        if self.another is not None:
            namespaceprefix_ = self.another_nsprefix_ + ':' if (UseCapturedNS_ and self.another_nsprefix_) else ''
            self.another.export(outfile, level, namespaceprefix_, namespacedef_='', name_='another', pretty_print=pretty_print)
        if self.public_servitude is not None:
            namespaceprefix_ = self.public_servitude_nsprefix_ + ':' if (UseCapturedNS_ and self.public_servitude_nsprefix_) else ''
            self.public_servitude.export(outfile, level, namespaceprefix_, namespacedef_='', name_='public_servitude', pretty_print=pretty_print)
        if self.undefined is not None:
            namespaceprefix_ = self.undefined_nsprefix_ + ':' if (UseCapturedNS_ and self.undefined_nsprefix_) else ''
            self.undefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='undefined', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'public_formation':
            obj_ = PublicFormations.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.public_formation = obj_
            obj_.original_tagname_ = 'public_formation'
        elif nodeName_ == 'individual':
            obj_ = IndividualOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.individual = obj_
            obj_.original_tagname_ = 'individual'
        elif nodeName_ == 'legal_entity':
            obj_ = LegalEntityOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.legal_entity = obj_
            obj_.original_tagname_ = 'legal_entity'
        elif nodeName_ == 'another':
            obj_ = AnotherRestricted.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.another = obj_
            obj_.original_tagname_ = 'another'
        elif nodeName_ == 'public_servitude':
            obj_ = PublicServitude.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.public_servitude = obj_
            obj_.original_tagname_ = 'public_servitude'
        elif nodeName_ == 'undefined':
            obj_ = Undefined.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.undefined = obj_
            obj_.original_tagname_ = 'undefined'
# end class SubjectRestricted


class AnotherRestricted(GeneratedsSuper):
    """AnotherRestricted -- И
    н
    о
    е
    л
    и
    ц
    о
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    о
    г
    о
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    another_type -- Т
    и
    п
    и
    н
    о
    г
    о
    с
    у
    б
    ъ
    е
    к
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, another_type=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.another_type = another_type
        self.another_type_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AnotherRestricted)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AnotherRestricted.subclass:
            return AnotherRestricted.subclass(*args_, **kwargs_)
        else:
            return AnotherRestricted(*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_another_type(self):
        return self.another_type
    def set_another_type(self, another_type):
        self.another_type = another_type
    def has__content(self):
        if (
            self.another_type is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherRestricted', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AnotherRestricted')
        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_ == 'AnotherRestricted':
            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_='AnotherRestricted')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AnotherRestricted', 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_='AnotherRestricted'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherRestricted', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.another_type is not None:
            namespaceprefix_ = self.another_type_nsprefix_ + ':' if (UseCapturedNS_ and self.another_type_nsprefix_) else ''
            self.another_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='another_type', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'another_type':
            obj_ = AnotherTypeRestricted.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.another_type = obj_
            obj_.original_tagname_ = 'another_type'
# end class AnotherRestricted


class AnotherTypeRestricted(GeneratedsSuper):
    """AnotherTypeRestricted -- Т
    и
    п
    и
    н
    о
    г
    о
    с
    у
    б
    ъ
    е
    к
    т
    а
    investment_unit_owner -- В
    л
    а
    д
    е
    л
    ь
    ц
    ы
    и
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    ы
    х
    п
    а
    е
    в
    certificates_holders -- В
    л
    а
    д
    е
    л
    ь
    ц
    ы
    и
    п
    о
    т
    е
    ч
    н
    ы
    х
    с
    е
    р
    т
    и
    ф
    и
    к
    а
    т
    о
    в
    у
    ч
    а
    с
    т
    и
    я
    bonds_holders -- В
    л
    а
    д
    е
    л
    ь
    ц
    ы
    о
    б
    л
    и
    г
    а
    ц
    и
    й
    partnership -- И
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    о
    е
    т
    о
    в
    а
    р
    и
    щ
    е
    с
    т
    в
    о
    aparthouse_owners -- С
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    в
    м
    н
    о
    г
    о
    к
    в
    а
    р
    т
    и
    р
    н
    о
    м
    д
    о
    м
    е
    equity_participants_info -- У
    ч
    а
    с
    т
    н
    и
    к
    и
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    п
    о
    д
    о
    г
    о
    в
    о
    р
    а
    м
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    not_equity_participants_info -- У
    ч
    а
    с
    т
    н
    и
    к
    и
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    п
    о
    д
    о
    г
    о
    в
    о
    р
    а
    м
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    ,
    к
    о
    т
    о
    р
    ы
    м
    н
    е
    п
    е
    р
    е
    д
    а
    н
    ы
    о
    б
    ъ
    е
    к
    т
    ы
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    other -- И
    н
    о
    й
    с
    у
    б
    ъ
    е
    к
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, investment_unit_owner=None, certificates_holders=None, bonds_holders=None, partnership=None, aparthouse_owners=None, equity_participants_info=None, not_equity_participants_info=None, other=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.investment_unit_owner = investment_unit_owner
        self.investment_unit_owner_nsprefix_ = None
        self.certificates_holders = certificates_holders
        self.certificates_holders_nsprefix_ = None
        self.bonds_holders = bonds_holders
        self.bonds_holders_nsprefix_ = None
        self.partnership = partnership
        self.partnership_nsprefix_ = None
        self.aparthouse_owners = aparthouse_owners
        self.aparthouse_owners_nsprefix_ = None
        self.equity_participants_info = equity_participants_info
        self.equity_participants_info_nsprefix_ = None
        self.not_equity_participants_info = not_equity_participants_info
        self.not_equity_participants_info_nsprefix_ = None
        self.other = other
        self.other_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AnotherTypeRestricted)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AnotherTypeRestricted.subclass:
            return AnotherTypeRestricted.subclass(*args_, **kwargs_)
        else:
            return AnotherTypeRestricted(*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_investment_unit_owner(self):
        return self.investment_unit_owner
    def set_investment_unit_owner(self, investment_unit_owner):
        self.investment_unit_owner = investment_unit_owner
    def get_certificates_holders(self):
        return self.certificates_holders
    def set_certificates_holders(self, certificates_holders):
        self.certificates_holders = certificates_holders
    def get_bonds_holders(self):
        return self.bonds_holders
    def set_bonds_holders(self, bonds_holders):
        self.bonds_holders = bonds_holders
    def get_partnership(self):
        return self.partnership
    def set_partnership(self, partnership):
        self.partnership = partnership
    def get_aparthouse_owners(self):
        return self.aparthouse_owners
    def set_aparthouse_owners(self, aparthouse_owners):
        self.aparthouse_owners = aparthouse_owners
    def get_equity_participants_info(self):
        return self.equity_participants_info
    def set_equity_participants_info(self, equity_participants_info):
        self.equity_participants_info = equity_participants_info
    def get_not_equity_participants_info(self):
        return self.not_equity_participants_info
    def set_not_equity_participants_info(self, not_equity_participants_info):
        self.not_equity_participants_info = not_equity_participants_info
    def get_other(self):
        return self.other
    def set_other(self, other):
        self.other = other
    def has__content(self):
        if (
            self.investment_unit_owner is not None or
            self.certificates_holders is not None or
            self.bonds_holders is not None or
            self.partnership is not None or
            self.aparthouse_owners is not None or
            self.equity_participants_info is not None or
            self.not_equity_participants_info is not None or
            self.other is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherTypeRestricted', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AnotherTypeRestricted')
        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_ == 'AnotherTypeRestricted':
            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_='AnotherTypeRestricted')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AnotherTypeRestricted', 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_='AnotherTypeRestricted'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherTypeRestricted', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.investment_unit_owner is not None:
            namespaceprefix_ = self.investment_unit_owner_nsprefix_ + ':' if (UseCapturedNS_ and self.investment_unit_owner_nsprefix_) else ''
            self.investment_unit_owner.export(outfile, level, namespaceprefix_, namespacedef_='', name_='investment_unit_owner', pretty_print=pretty_print)
        if self.certificates_holders is not None:
            namespaceprefix_ = self.certificates_holders_nsprefix_ + ':' if (UseCapturedNS_ and self.certificates_holders_nsprefix_) else ''
            self.certificates_holders.export(outfile, level, namespaceprefix_, namespacedef_='', name_='certificates_holders', pretty_print=pretty_print)
        if self.bonds_holders is not None:
            namespaceprefix_ = self.bonds_holders_nsprefix_ + ':' if (UseCapturedNS_ and self.bonds_holders_nsprefix_) else ''
            self.bonds_holders.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bonds_holders', pretty_print=pretty_print)
        if self.partnership is not None:
            namespaceprefix_ = self.partnership_nsprefix_ + ':' if (UseCapturedNS_ and self.partnership_nsprefix_) else ''
            self.partnership.export(outfile, level, namespaceprefix_, namespacedef_='', name_='partnership', pretty_print=pretty_print)
        if self.aparthouse_owners is not None:
            namespaceprefix_ = self.aparthouse_owners_nsprefix_ + ':' if (UseCapturedNS_ and self.aparthouse_owners_nsprefix_) else ''
            self.aparthouse_owners.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aparthouse_owners', pretty_print=pretty_print)
        if self.equity_participants_info is not None:
            namespaceprefix_ = self.equity_participants_info_nsprefix_ + ':' if (UseCapturedNS_ and self.equity_participants_info_nsprefix_) else ''
            self.equity_participants_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equity_participants_info', pretty_print=pretty_print)
        if self.not_equity_participants_info is not None:
            namespaceprefix_ = self.not_equity_participants_info_nsprefix_ + ':' if (UseCapturedNS_ and self.not_equity_participants_info_nsprefix_) else ''
            self.not_equity_participants_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='not_equity_participants_info', pretty_print=pretty_print)
        if self.other is not None:
            namespaceprefix_ = self.other_nsprefix_ + ':' if (UseCapturedNS_ and self.other_nsprefix_) else ''
            self.other.export(outfile, level, namespaceprefix_, namespacedef_='', name_='other', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'investment_unit_owner':
            obj_ = InvestmentUnitOwnerOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.investment_unit_owner = obj_
            obj_.original_tagname_ = 'investment_unit_owner'
        elif nodeName_ == 'certificates_holders':
            obj_ = CertificatesHoldersOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.certificates_holders = obj_
            obj_.original_tagname_ = 'certificates_holders'
        elif nodeName_ == 'bonds_holders':
            obj_ = BondsHoldersOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.bonds_holders = obj_
            obj_.original_tagname_ = 'bonds_holders'
        elif nodeName_ == 'partnership':
            obj_ = Partnership.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.partnership = obj_
            obj_.original_tagname_ = 'partnership'
        elif nodeName_ == 'aparthouse_owners':
            obj_ = AparthouseOwners.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.aparthouse_owners = obj_
            obj_.original_tagname_ = 'aparthouse_owners'
        elif nodeName_ == 'equity_participants_info':
            obj_ = EquityParticipantsInfo.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.equity_participants_info = obj_
            obj_.original_tagname_ = 'equity_participants_info'
        elif nodeName_ == 'not_equity_participants_info':
            obj_ = NotEquityParticipantsInfo.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.not_equity_participants_info = obj_
            obj_.original_tagname_ = 'not_equity_participants_info'
        elif nodeName_ == 'other':
            obj_ = OtherSubject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.other = obj_
            obj_.original_tagname_ = 'other'
# end class AnotherTypeRestricted


class DealParties(GeneratedsSuper):
    """DealParties -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    а
    х
    ,
    у
    ч
    а
    с
    т
    в
    у
    ю
    щ
    и
    х
    в
    с
    д
    е
    л
    к
    е
    deal_party -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    е
    ,
    у
    ч
    а
    с
    т
    в
    у
    ю
    щ
    е
    м
    в
    с
    д
    е
    л
    к
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, deal_party=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 deal_party is None:
            self.deal_party = []
        else:
            self.deal_party = deal_party
        self.deal_party_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DealParties)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DealParties.subclass:
            return DealParties.subclass(*args_, **kwargs_)
        else:
            return DealParties(*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_deal_party(self):
        return self.deal_party
    def set_deal_party(self, deal_party):
        self.deal_party = deal_party
    def add_deal_party(self, value):
        self.deal_party.append(value)
    def insert_deal_party_at(self, index, value):
        self.deal_party.insert(index, value)
    def replace_deal_party_at(self, index, value):
        self.deal_party[index] = value
    def has__content(self):
        if (
            self.deal_party
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealParties', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DealParties')
        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_ == 'DealParties':
            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_='DealParties')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DealParties', 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_='DealParties'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealParties', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for deal_party_ in self.deal_party:
            namespaceprefix_ = self.deal_party_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_party_nsprefix_) else ''
            deal_party_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deal_party', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'deal_party':
            obj_ = DealParty.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deal_party.append(obj_)
            obj_.original_tagname_ = 'deal_party'
# end class DealParties


class DealParty(GeneratedsSuper):
    """DealParty -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    е
    ,
    у
    ч
    а
    с
    т
    в
    у
    ю
    щ
    е
    м
    в
    с
    д
    е
    л
    к
    е
    concession_mark -- С
    о
    в
    е
    р
    ш
    е
    н
    а
    у
    с
    т
    у
    п
    к
    а
    п
    р
    а
    в
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    в
    п
    о
    л
    ь
    з
    у
    л
    и
    ц
    а
    party_type -- Т
    и
    п
    л
    и
    ц
    а
    ,
    у
    ч
    а
    с
    т
    в
    у
    ю
    щ
    е
    г
    о
    в
    с
    д
    е
    л
    к
    е
    party_info -- Л
    и
    ц
    о
    ,
    у
    ч
    а
    с
    т
    в
    у
    ю
    щ
    е
    е
    в
    с
    д
    е
    л
    к
    е
    infant -- П
    р
    е
    д
    с
    т
    а
    в
    и
    т
    е
    л
    ь
    н
    е
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    о
    л
    е
    т
    н
    е
    г
    о
    ,
    н
    е
    д
    о
    с
    т
    и
    г
    ш
    е
    г
    о
    ч
    е
    т
    ы
    р
    н
    а
    д
    ц
    а
    т
    и
    л
    е
    т
    (
    м
    а
    л
    о
    л
    е
    т
    н
    е
    г
    о
    ),
    и
    л
    и
    п
    р
    и
    з
    н
    а
    н
    н
    о
    г
    о
    н
    е
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    л
    и
    ц
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, concession_mark=None, party_type=None, party_info=None, infant=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.concession_mark = concession_mark
        self.concession_mark_nsprefix_ = None
        self.party_type = party_type
        self.party_type_nsprefix_ = None
        self.party_info = party_info
        self.party_info_nsprefix_ = None
        self.infant = infant
        self.infant_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DealParty)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DealParty.subclass:
            return DealParty.subclass(*args_, **kwargs_)
        else:
            return DealParty(*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_concession_mark(self):
        return self.concession_mark
    def set_concession_mark(self, concession_mark):
        self.concession_mark = concession_mark
    def get_party_type(self):
        return self.party_type
    def set_party_type(self, party_type):
        self.party_type = party_type
    def get_party_info(self):
        return self.party_info
    def set_party_info(self, party_info):
        self.party_info = party_info
    def get_infant(self):
        return self.infant
    def set_infant(self, infant):
        self.infant = infant
    def has__content(self):
        if (
            self.concession_mark is not None or
            self.party_type is not None or
            self.party_info is not None or
            self.infant is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealParty', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DealParty')
        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_ == 'DealParty':
            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_='DealParty')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DealParty', 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_='DealParty'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealParty', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.concession_mark is not None:
            namespaceprefix_ = self.concession_mark_nsprefix_ + ':' if (UseCapturedNS_ and self.concession_mark_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sconcession_mark>%s</%sconcession_mark>%s' % (namespaceprefix_ , self.gds_format_boolean(self.concession_mark, input_name='concession_mark'), namespaceprefix_ , eol_))
        if self.party_type is not None:
            namespaceprefix_ = self.party_type_nsprefix_ + ':' if (UseCapturedNS_ and self.party_type_nsprefix_) else ''
            self.party_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='party_type', pretty_print=pretty_print)
        if self.party_info is not None:
            namespaceprefix_ = self.party_info_nsprefix_ + ':' if (UseCapturedNS_ and self.party_info_nsprefix_) else ''
            self.party_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='party_info', pretty_print=pretty_print)
        if self.infant is not None:
            namespaceprefix_ = self.infant_nsprefix_ + ':' if (UseCapturedNS_ and self.infant_nsprefix_) else ''
            self.infant.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infant', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'concession_mark':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'concession_mark')
            ival_ = self.gds_validate_boolean(ival_, node, 'concession_mark')
            self.concession_mark = ival_
            self.concession_mark_nsprefix_ = child_.prefix
        elif nodeName_ == 'party_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.party_type = obj_
            obj_.original_tagname_ = 'party_type'
        elif nodeName_ == 'party_info':
            obj_ = RightHolderOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.party_info = obj_
            obj_.original_tagname_ = 'party_info'
        elif nodeName_ == 'infant':
            obj_ = Infant.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.infant = obj_
            obj_.original_tagname_ = 'infant'
# end class DealParty


class Infant(GeneratedsSuper):
    """Infant -- П
    р
    е
    д
    с
    т
    а
    в
    и
    т
    е
    л
    ь
    н
    е
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    о
    л
    е
    т
    н
    е
    г
    о
    ,
    н
    е
    д
    о
    с
    т
    и
    г
    ш
    е
    г
    о
    ч
    е
    т
    ы
    р
    н
    а
    д
    ц
    а
    т
    и
    л
    е
    т
    (
    м
    а
    л
    о
    л
    е
    т
    н
    е
    г
    о
    ),
    и
    л
    и
    п
    р
    и
    з
    н
    а
    н
    н
    о
    г
    о
    н
    е
    д
    е
    е
    с
    п
    о
    с
    о
    б
    н
    ы
    м
    л
    и
    ц
    а
    representative -- П
    р
    е
    д
    с
    т
    а
    в
    и
    т
    е
    л
    ь
    л
    и
    ц
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, representative=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.representative = representative
        self.representative_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Infant)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Infant.subclass:
            return Infant.subclass(*args_, **kwargs_)
        else:
            return Infant(*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_representative(self):
        return self.representative
    def set_representative(self, representative):
        self.representative = representative
    def has__content(self):
        if (
            self.representative is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Infant', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Infant')
        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_ == 'Infant':
            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_='Infant')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Infant', 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_='Infant'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Infant', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.representative is not None:
            namespaceprefix_ = self.representative_nsprefix_ + ':' if (UseCapturedNS_ and self.representative_nsprefix_) else ''
            self.representative.export(outfile, level, namespaceprefix_, namespacedef_='', name_='representative', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'representative':
            obj_ = Representative.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.representative = obj_
            obj_.original_tagname_ = 'representative'
# end class Infant


class Representative(GeneratedsSuper):
    """Representative -- П
    р
    е
    д
    с
    т
    а
    в
    и
    т
    е
    л
    ь
    л
    и
    ц
    а
    representative_type -- Т
    и
    п
    п
    р
    е
    д
    с
    т
    а
    в
    и
    т
    е
    л
    я
    representative_kind -- П
    р
    е
    д
    с
    т
    а
    в
    и
    т
    е
    л
    ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, representative_type=None, representative_kind=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.representative_type = representative_type
        self.representative_type_nsprefix_ = None
        self.representative_kind = representative_kind
        self.representative_kind_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Representative)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Representative.subclass:
            return Representative.subclass(*args_, **kwargs_)
        else:
            return Representative(*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_representative_type(self):
        return self.representative_type
    def set_representative_type(self, representative_type):
        self.representative_type = representative_type
    def get_representative_kind(self):
        return self.representative_kind
    def set_representative_kind(self, representative_kind):
        self.representative_kind = representative_kind
    def has__content(self):
        if (
            self.representative_type is not None or
            self.representative_kind is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Representative', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Representative')
        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_ == 'Representative':
            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_='Representative')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Representative', 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_='Representative'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Representative', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.representative_type is not None:
            namespaceprefix_ = self.representative_type_nsprefix_ + ':' if (UseCapturedNS_ and self.representative_type_nsprefix_) else ''
            self.representative_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='representative_type', pretty_print=pretty_print)
        if self.representative_kind is not None:
            namespaceprefix_ = self.representative_kind_nsprefix_ + ':' if (UseCapturedNS_ and self.representative_kind_nsprefix_) else ''
            self.representative_kind.export(outfile, level, namespaceprefix_, namespacedef_='', name_='representative_kind', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'representative_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.representative_type = obj_
            obj_.original_tagname_ = 'representative_type'
        elif nodeName_ == 'representative_kind':
            obj_ = RepresentativeKind.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.representative_kind = obj_
            obj_.original_tagname_ = 'representative_kind'
# end class Representative


class RepresentativeKind(GeneratedsSuper):
    """RepresentativeKind -- П
    р
    е
    д
    с
    т
    а
    в
    и
    т
    е
    л
    ь
    individual -- Ф
    и
    з
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    legal_entity -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, individual=None, legal_entity=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.individual = individual
        self.individual_nsprefix_ = None
        self.legal_entity = legal_entity
        self.legal_entity_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RepresentativeKind)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RepresentativeKind.subclass:
            return RepresentativeKind.subclass(*args_, **kwargs_)
        else:
            return RepresentativeKind(*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_individual(self):
        return self.individual
    def set_individual(self, individual):
        self.individual = individual
    def get_legal_entity(self):
        return self.legal_entity
    def set_legal_entity(self, legal_entity):
        self.legal_entity = legal_entity
    def has__content(self):
        if (
            self.individual is not None or
            self.legal_entity is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RepresentativeKind', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RepresentativeKind')
        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_ == 'RepresentativeKind':
            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_='RepresentativeKind')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RepresentativeKind', 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_='RepresentativeKind'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RepresentativeKind', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.individual is not None:
            namespaceprefix_ = self.individual_nsprefix_ + ':' if (UseCapturedNS_ and self.individual_nsprefix_) else ''
            self.individual.export(outfile, level, namespaceprefix_, namespacedef_='', name_='individual', pretty_print=pretty_print)
        if self.legal_entity is not None:
            namespaceprefix_ = self.legal_entity_nsprefix_ + ':' if (UseCapturedNS_ and self.legal_entity_nsprefix_) else ''
            self.legal_entity.export(outfile, level, namespaceprefix_, namespacedef_='', name_='legal_entity', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'individual':
            obj_ = IndividualOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.individual = obj_
            obj_.original_tagname_ = 'individual'
        elif nodeName_ == 'legal_entity':
            obj_ = LegalEntityOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.legal_entity = obj_
            obj_.original_tagname_ = 'legal_entity'
# end class RepresentativeKind


class IndividualOut(GeneratedsSuper):
    """IndividualOut -- П
    о
    л
    н
    ы
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    ф
    и
    з
    и
    ч
    е
    с
    к
    о
    м
    л
    и
    ц
    е
    individual_type -- Т
    и
    п
    ф
    и
    з
    и
    ч
    е
    с
    к
    о
    г
    о
    л
    и
    ц
    а
    surname -- Ф
    а
    м
    и
    л
    и
    я
    name -- И
    м
    я
    patronymic -- О
    т
    ч
    е
    с
    т
    в
    о
    birth_date -- Д
    а
    т
    а
    р
    о
    ж
    д
    е
    н
    и
    я
    birth_place -- М
    е
    с
    т
    о
    р
    о
    ж
    д
    е
    н
    и
    я
    citizenship -- Г
    р
    а
    ж
    д
    а
    н
    с
    т
    в
    о
    snils -- С
    Н
    И
    Л
    С
    identity_doc -- Д
    о
    к
    у
    м
    е
    н
    т
    ,
    у
    д
    о
    с
    т
    о
    в
    е
    р
    я
    ю
    щ
    и
    й
    л
    и
    ч
    н
    о
    с
    т
    ь
    contacts -- К
    о
    н
    т
    а
    к
    т
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, individual_type=None, surname=None, name=None, patronymic=None, birth_date=None, birth_place=None, citizenship=None, snils=None, identity_doc=None, contacts=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.individual_type = individual_type
        self.individual_type_nsprefix_ = None
        self.surname = surname
        self.surname_nsprefix_ = None
        self.name = name
        self.name_nsprefix_ = None
        self.patronymic = patronymic
        self.patronymic_nsprefix_ = None
        if isinstance(birth_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(birth_date, '%Y-%m-%d').date()
        else:
            initvalue_ = birth_date
        self.birth_date = initvalue_
        self.birth_date_nsprefix_ = None
        self.birth_place = birth_place
        self.validate_MultiLiner(self.birth_place)
        self.birth_place_nsprefix_ = None
        self.citizenship = citizenship
        self.citizenship_nsprefix_ = None
        self.snils = snils
        self.snils_nsprefix_ = None
        self.identity_doc = identity_doc
        self.identity_doc_nsprefix_ = None
        self.contacts = contacts
        self.contacts_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IndividualOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IndividualOut.subclass:
            return IndividualOut.subclass(*args_, **kwargs_)
        else:
            return IndividualOut(*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_individual_type(self):
        return self.individual_type
    def set_individual_type(self, individual_type):
        self.individual_type = individual_type
    def get_surname(self):
        return self.surname
    def set_surname(self, surname):
        self.surname = surname
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_patronymic(self):
        return self.patronymic
    def set_patronymic(self, patronymic):
        self.patronymic = patronymic
    def get_birth_date(self):
        return self.birth_date
    def set_birth_date(self, birth_date):
        self.birth_date = birth_date
    def get_birth_place(self):
        return self.birth_place
    def set_birth_place(self, birth_place):
        self.birth_place = birth_place
    def get_citizenship(self):
        return self.citizenship
    def set_citizenship(self, citizenship):
        self.citizenship = citizenship
    def get_snils(self):
        return self.snils
    def set_snils(self, snils):
        self.snils = snils
    def get_identity_doc(self):
        return self.identity_doc
    def set_identity_doc(self, identity_doc):
        self.identity_doc = identity_doc
    def get_contacts(self):
        return self.contacts
    def set_contacts(self, contacts):
        self.contacts = contacts
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.individual_type is not None or
            self.surname is not None or
            self.name is not None or
            self.patronymic is not None or
            self.birth_date is not None or
            self.birth_place is not None or
            self.citizenship is not None or
            self.snils is not None or
            self.identity_doc is not None or
            self.contacts is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IndividualOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IndividualOut')
        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_ == 'IndividualOut':
            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_='IndividualOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IndividualOut', 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_='IndividualOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IndividualOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.individual_type is not None:
            namespaceprefix_ = self.individual_type_nsprefix_ + ':' if (UseCapturedNS_ and self.individual_type_nsprefix_) else ''
            self.individual_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='individual_type', pretty_print=pretty_print)
        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.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.patronymic is not None:
            namespaceprefix_ = self.patronymic_nsprefix_ + ':' if (UseCapturedNS_ and self.patronymic_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spatronymic>%s</%spatronymic>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.patronymic), input_name='patronymic')), namespaceprefix_ , eol_))
        if self.birth_date is not None:
            namespaceprefix_ = self.birth_date_nsprefix_ + ':' if (UseCapturedNS_ and self.birth_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbirth_date>%s</%sbirth_date>%s' % (namespaceprefix_ , self.gds_format_date(self.birth_date, input_name='birth_date'), namespaceprefix_ , eol_))
        if self.birth_place is not None:
            namespaceprefix_ = self.birth_place_nsprefix_ + ':' if (UseCapturedNS_ and self.birth_place_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbirth_place>%s</%sbirth_place>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.birth_place), input_name='birth_place')), namespaceprefix_ , eol_))
        if self.citizenship is not None:
            namespaceprefix_ = self.citizenship_nsprefix_ + ':' if (UseCapturedNS_ and self.citizenship_nsprefix_) else ''
            self.citizenship.export(outfile, level, namespaceprefix_, namespacedef_='', name_='citizenship', pretty_print=pretty_print)
        if self.snils is not None:
            namespaceprefix_ = self.snils_nsprefix_ + ':' if (UseCapturedNS_ and self.snils_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssnils>%s</%ssnils>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.snils), input_name='snils')), namespaceprefix_ , eol_))
        if self.identity_doc is not None:
            namespaceprefix_ = self.identity_doc_nsprefix_ + ':' if (UseCapturedNS_ and self.identity_doc_nsprefix_) else ''
            self.identity_doc.export(outfile, level, namespaceprefix_, namespacedef_='', name_='identity_doc', pretty_print=pretty_print)
        if self.contacts is not None:
            namespaceprefix_ = self.contacts_nsprefix_ + ':' if (UseCapturedNS_ and self.contacts_nsprefix_) else ''
            self.contacts.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contacts', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'individual_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.individual_type = obj_
            obj_.original_tagname_ = 'individual_type'
        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_ == '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_ == 'patronymic':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'patronymic')
            value_ = self.gds_validate_string(value_, node, 'patronymic')
            self.patronymic = value_
            self.patronymic_nsprefix_ = child_.prefix
        elif nodeName_ == 'birth_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.birth_date = dval_
            self.birth_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'birth_place':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'birth_place')
            value_ = self.gds_validate_string(value_, node, 'birth_place')
            self.birth_place = value_
            self.birth_place_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.birth_place)
        elif nodeName_ == 'citizenship':
            obj_ = Citizenship.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.citizenship = obj_
            obj_.original_tagname_ = 'citizenship'
        elif nodeName_ == 'snils':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'snils')
            value_ = self.gds_validate_string(value_, node, 'snils')
            self.snils = value_
            self.snils_nsprefix_ = child_.prefix
        elif nodeName_ == 'identity_doc':
            obj_ = PersonDocument.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.identity_doc = obj_
            obj_.original_tagname_ = 'identity_doc'
        elif nodeName_ == 'contacts':
            obj_ = Contacts.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contacts = obj_
            obj_.original_tagname_ = 'contacts'
# end class IndividualOut


class IndividualFull(GeneratedsSuper):
    """IndividualFull -- П
    о
    л
    н
    ы
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    ф
    и
    з
    и
    ч
    е
    с
    к
    о
    м
    л
    и
    ц
    е
    individual_type -- Т
    и
    п
    ф
    и
    з
    и
    ч
    е
    с
    к
    о
    г
    о
    л
    и
    ц
    а
    surname -- Ф
    а
    м
    и
    л
    и
    я
    name -- И
    м
    я
    patronymic -- О
    т
    ч
    е
    с
    т
    в
    о
    birth_date -- Д
    а
    т
    а
    р
    о
    ж
    д
    е
    н
    и
    я
    birth_place -- М
    е
    с
    т
    о
    р
    о
    ж
    д
    е
    н
    и
    я
    citizenship -- Г
    р
    а
    ж
    д
    а
    н
    с
    т
    в
    о
    snils -- С
    Н
    И
    Л
    С
    identity_doc -- Д
    о
    к
    у
    м
    е
    н
    т
    ,
    у
    д
    о
    с
    т
    о
    в
    е
    р
    я
    ю
    щ
    и
    й
    л
    и
    ч
    н
    о
    с
    т
    ь
    contacts -- К
    о
    н
    т
    а
    к
    т
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, individual_type=None, surname=None, name=None, patronymic=None, birth_date=None, birth_place=None, citizenship=None, snils=None, identity_doc=None, contacts=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.individual_type = individual_type
        self.individual_type_nsprefix_ = None
        self.surname = surname
        self.surname_nsprefix_ = None
        self.name = name
        self.name_nsprefix_ = None
        self.patronymic = patronymic
        self.patronymic_nsprefix_ = None
        if isinstance(birth_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(birth_date, '%Y-%m-%d').date()
        else:
            initvalue_ = birth_date
        self.birth_date = initvalue_
        self.birth_date_nsprefix_ = None
        self.birth_place = birth_place
        self.validate_MultiLiner(self.birth_place)
        self.birth_place_nsprefix_ = None
        self.citizenship = citizenship
        self.citizenship_nsprefix_ = None
        self.snils = snils
        self.snils_nsprefix_ = None
        self.identity_doc = identity_doc
        self.identity_doc_nsprefix_ = None
        self.contacts = contacts
        self.contacts_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, IndividualFull)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if IndividualFull.subclass:
            return IndividualFull.subclass(*args_, **kwargs_)
        else:
            return IndividualFull(*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_individual_type(self):
        return self.individual_type
    def set_individual_type(self, individual_type):
        self.individual_type = individual_type
    def get_surname(self):
        return self.surname
    def set_surname(self, surname):
        self.surname = surname
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_patronymic(self):
        return self.patronymic
    def set_patronymic(self, patronymic):
        self.patronymic = patronymic
    def get_birth_date(self):
        return self.birth_date
    def set_birth_date(self, birth_date):
        self.birth_date = birth_date
    def get_birth_place(self):
        return self.birth_place
    def set_birth_place(self, birth_place):
        self.birth_place = birth_place
    def get_citizenship(self):
        return self.citizenship
    def set_citizenship(self, citizenship):
        self.citizenship = citizenship
    def get_snils(self):
        return self.snils
    def set_snils(self, snils):
        self.snils = snils
    def get_identity_doc(self):
        return self.identity_doc
    def set_identity_doc(self, identity_doc):
        self.identity_doc = identity_doc
    def get_contacts(self):
        return self.contacts
    def set_contacts(self, contacts):
        self.contacts = contacts
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.individual_type is not None or
            self.surname is not None or
            self.name is not None or
            self.patronymic is not None or
            self.birth_date is not None or
            self.birth_place is not None or
            self.citizenship is not None or
            self.snils is not None or
            self.identity_doc is not None or
            self.contacts is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IndividualFull', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('IndividualFull')
        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_ == 'IndividualFull':
            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_='IndividualFull')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='IndividualFull', 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_='IndividualFull'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='IndividualFull', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.individual_type is not None:
            namespaceprefix_ = self.individual_type_nsprefix_ + ':' if (UseCapturedNS_ and self.individual_type_nsprefix_) else ''
            self.individual_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='individual_type', pretty_print=pretty_print)
        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.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.patronymic is not None:
            namespaceprefix_ = self.patronymic_nsprefix_ + ':' if (UseCapturedNS_ and self.patronymic_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spatronymic>%s</%spatronymic>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.patronymic), input_name='patronymic')), namespaceprefix_ , eol_))
        if self.birth_date is not None:
            namespaceprefix_ = self.birth_date_nsprefix_ + ':' if (UseCapturedNS_ and self.birth_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbirth_date>%s</%sbirth_date>%s' % (namespaceprefix_ , self.gds_format_date(self.birth_date, input_name='birth_date'), namespaceprefix_ , eol_))
        if self.birth_place is not None:
            namespaceprefix_ = self.birth_place_nsprefix_ + ':' if (UseCapturedNS_ and self.birth_place_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbirth_place>%s</%sbirth_place>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.birth_place), input_name='birth_place')), namespaceprefix_ , eol_))
        if self.citizenship is not None:
            namespaceprefix_ = self.citizenship_nsprefix_ + ':' if (UseCapturedNS_ and self.citizenship_nsprefix_) else ''
            self.citizenship.export(outfile, level, namespaceprefix_, namespacedef_='', name_='citizenship', pretty_print=pretty_print)
        if self.snils is not None:
            namespaceprefix_ = self.snils_nsprefix_ + ':' if (UseCapturedNS_ and self.snils_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssnils>%s</%ssnils>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.snils), input_name='snils')), namespaceprefix_ , eol_))
        if self.identity_doc is not None:
            namespaceprefix_ = self.identity_doc_nsprefix_ + ':' if (UseCapturedNS_ and self.identity_doc_nsprefix_) else ''
            self.identity_doc.export(outfile, level, namespaceprefix_, namespacedef_='', name_='identity_doc', pretty_print=pretty_print)
        if self.contacts is not None:
            namespaceprefix_ = self.contacts_nsprefix_ + ':' if (UseCapturedNS_ and self.contacts_nsprefix_) else ''
            self.contacts.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contacts', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'individual_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.individual_type = obj_
            obj_.original_tagname_ = 'individual_type'
        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_ == '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_ == 'patronymic':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'patronymic')
            value_ = self.gds_validate_string(value_, node, 'patronymic')
            self.patronymic = value_
            self.patronymic_nsprefix_ = child_.prefix
        elif nodeName_ == 'birth_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.birth_date = dval_
            self.birth_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'birth_place':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'birth_place')
            value_ = self.gds_validate_string(value_, node, 'birth_place')
            self.birth_place = value_
            self.birth_place_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.birth_place)
        elif nodeName_ == 'citizenship':
            obj_ = Citizenship.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.citizenship = obj_
            obj_.original_tagname_ = 'citizenship'
        elif nodeName_ == 'snils':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'snils')
            value_ = self.gds_validate_string(value_, node, 'snils')
            self.snils = value_
            self.snils_nsprefix_ = child_.prefix
        elif nodeName_ == 'identity_doc':
            obj_ = PersonDocument.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.identity_doc = obj_
            obj_.original_tagname_ = 'identity_doc'
        elif nodeName_ == 'contacts':
            obj_ = Contacts.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contacts = obj_
            obj_.original_tagname_ = 'contacts'
# end class IndividualFull


class Citizenship(GeneratedsSuper):
    """Citizenship -- Г
    р
    а
    ж
    д
    а
    н
    с
    т
    в
    о
    person_citizenship_country -- С
    т
    р
    а
    н
    а
    г
    р
    а
    ж
    д
    а
    н
    с
    т
    в
    а
    no_citizenship_person -- Л
    и
    ц
    о
    б
    е
    з
    г
    р
    а
    ж
    д
    а
    н
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, person_citizenship_country=None, no_citizenship_person=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.person_citizenship_country = person_citizenship_country
        self.person_citizenship_country_nsprefix_ = None
        self.no_citizenship_person = no_citizenship_person
        self.no_citizenship_person_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Citizenship)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Citizenship.subclass:
            return Citizenship.subclass(*args_, **kwargs_)
        else:
            return Citizenship(*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_person_citizenship_country(self):
        return self.person_citizenship_country
    def set_person_citizenship_country(self, person_citizenship_country):
        self.person_citizenship_country = person_citizenship_country
    def get_no_citizenship_person(self):
        return self.no_citizenship_person
    def set_no_citizenship_person(self, no_citizenship_person):
        self.no_citizenship_person = no_citizenship_person
    def has__content(self):
        if (
            self.person_citizenship_country is not None or
            self.no_citizenship_person is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Citizenship', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Citizenship')
        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_ == 'Citizenship':
            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_='Citizenship')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Citizenship', 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_='Citizenship'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Citizenship', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.person_citizenship_country is not None:
            namespaceprefix_ = self.person_citizenship_country_nsprefix_ + ':' if (UseCapturedNS_ and self.person_citizenship_country_nsprefix_) else ''
            self.person_citizenship_country.export(outfile, level, namespaceprefix_, namespacedef_='', name_='person_citizenship_country', pretty_print=pretty_print)
        if self.no_citizenship_person is not None:
            namespaceprefix_ = self.no_citizenship_person_nsprefix_ + ':' if (UseCapturedNS_ and self.no_citizenship_person_nsprefix_) else ''
            self.no_citizenship_person.export(outfile, level, namespaceprefix_, namespacedef_='', name_='no_citizenship_person', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'person_citizenship_country':
            obj_ = PersonCitizenshipCountry.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.person_citizenship_country = obj_
            obj_.original_tagname_ = 'person_citizenship_country'
        elif nodeName_ == 'no_citizenship_person':
            obj_ = NoCitizenshipPerson.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.no_citizenship_person = obj_
            obj_.original_tagname_ = 'no_citizenship_person'
# end class Citizenship


class PersonCitizenshipCountry(GeneratedsSuper):
    """PersonCitizenshipCountry -- С
    т
    р
    а
    н
    а
    г
    р
    а
    ж
    д
    а
    н
    с
    т
    в
    а
    citizenship_country -- С
    т
    р
    а
    н
    а
    г
    р
    а
    ж
    д
    а
    н
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, citizenship_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.citizenship_country = citizenship_country
        self.citizenship_country_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PersonCitizenshipCountry)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PersonCitizenshipCountry.subclass:
            return PersonCitizenshipCountry.subclass(*args_, **kwargs_)
        else:
            return PersonCitizenshipCountry(*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_citizenship_country(self):
        return self.citizenship_country
    def set_citizenship_country(self, citizenship_country):
        self.citizenship_country = citizenship_country
    def has__content(self):
        if (
            self.citizenship_country is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PersonCitizenshipCountry', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PersonCitizenshipCountry')
        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_ == 'PersonCitizenshipCountry':
            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_='PersonCitizenshipCountry')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PersonCitizenshipCountry', 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_='PersonCitizenshipCountry'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PersonCitizenshipCountry', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.citizenship_country is not None:
            namespaceprefix_ = self.citizenship_country_nsprefix_ + ':' if (UseCapturedNS_ and self.citizenship_country_nsprefix_) else ''
            self.citizenship_country.export(outfile, level, namespaceprefix_, namespacedef_='', name_='citizenship_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'citizenship_country':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.citizenship_country = obj_
            obj_.original_tagname_ = 'citizenship_country'
# end class PersonCitizenshipCountry


class NoCitizenshipPerson(GeneratedsSuper):
    """NoCitizenshipPerson -- Л
    и
    ц
    о
    б
    е
    з
    г
    р
    а
    ж
    д
    а
    н
    с
    т
    в
    а
    no_citizenship -- Б
    е
    з
    г
    р
    а
    ж
    д
    а
    н
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, no_citizenship=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.no_citizenship = no_citizenship
        self.no_citizenship_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, NoCitizenshipPerson)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if NoCitizenshipPerson.subclass:
            return NoCitizenshipPerson.subclass(*args_, **kwargs_)
        else:
            return NoCitizenshipPerson(*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_no_citizenship(self):
        return self.no_citizenship
    def set_no_citizenship(self, no_citizenship):
        self.no_citizenship = no_citizenship
    def has__content(self):
        if (
            self.no_citizenship is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NoCitizenshipPerson', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('NoCitizenshipPerson')
        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_ == 'NoCitizenshipPerson':
            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_='NoCitizenshipPerson')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NoCitizenshipPerson', 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_='NoCitizenshipPerson'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NoCitizenshipPerson', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.no_citizenship is not None:
            namespaceprefix_ = self.no_citizenship_nsprefix_ + ':' if (UseCapturedNS_ and self.no_citizenship_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sno_citizenship>%s</%sno_citizenship>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.no_citizenship), input_name='no_citizenship')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'no_citizenship':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'no_citizenship')
            value_ = self.gds_validate_string(value_, node, 'no_citizenship')
            self.no_citizenship = value_
            self.no_citizenship_nsprefix_ = child_.prefix
# end class NoCitizenshipPerson


class LegalEntityOut(GeneratedsSuper):
    """LegalEntityOut -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    ,
    о
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    type -- Т
    и
    п
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    г
    о
    л
    и
    ц
    а
    entity -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    ,
    о
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    contacts -- К
    о
    н
    т
    а
    к
    т
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_=None, entity=None, contacts=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.type_ = type_
        self.type__nsprefix_ = None
        self.entity = entity
        self.entity_nsprefix_ = None
        self.contacts = contacts
        self.contacts_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LegalEntityOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LegalEntityOut.subclass:
            return LegalEntityOut.subclass(*args_, **kwargs_)
        else:
            return LegalEntityOut(*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_type(self):
        return self.type_
    def set_type(self, type_):
        self.type_ = type_
    def get_entity(self):
        return self.entity
    def set_entity(self, entity):
        self.entity = entity
    def get_contacts(self):
        return self.contacts
    def set_contacts(self, contacts):
        self.contacts = contacts
    def has__content(self):
        if (
            self.type_ is not None or
            self.entity is not None or
            self.contacts is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LegalEntityOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LegalEntityOut')
        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_ == 'LegalEntityOut':
            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_='LegalEntityOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LegalEntityOut', 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_='LegalEntityOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LegalEntityOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_ is not None:
            namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else ''
            self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', pretty_print=pretty_print)
        if self.entity is not None:
            namespaceprefix_ = self.entity_nsprefix_ + ':' if (UseCapturedNS_ and self.entity_nsprefix_) else ''
            self.entity.export(outfile, level, namespaceprefix_, namespacedef_='', name_='entity', pretty_print=pretty_print)
        if self.contacts is not None:
            namespaceprefix_ = self.contacts_nsprefix_ + ':' if (UseCapturedNS_ and self.contacts_nsprefix_) else ''
            self.contacts.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contacts', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
        elif nodeName_ == 'entity':
            obj_ = EntityOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.entity = obj_
            obj_.original_tagname_ = 'entity'
        elif nodeName_ == 'contacts':
            obj_ = Contacts.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contacts = obj_
            obj_.original_tagname_ = 'contacts'
# end class LegalEntityOut


class EntityOut(GeneratedsSuper):
    """EntityOut -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    ,
    о
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    resident -- Р
    о
    с
    с
    и
    й
    с
    к
    о
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    govement_entity -- О
    р
    г
    а
    н
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    в
    л
    а
    с
    т
    и
    ,
    о
    р
    г
    а
    н
    м
    е
    с
    т
    н
    о
    г
    о
    с
    а
    м
    о
    у
    п
    р
    а
    в
    л
    е
    н
    и
    я
    ,
    и
    н
    о
    й
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    й
    о
    р
    г
    а
    н
    not_resident -- И
    н
    о
    с
    т
    р
    а
    н
    н
    о
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, resident=None, govement_entity=None, not_resident=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.resident = resident
        self.resident_nsprefix_ = None
        self.govement_entity = govement_entity
        self.govement_entity_nsprefix_ = None
        self.not_resident = not_resident
        self.not_resident_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, EntityOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if EntityOut.subclass:
            return EntityOut.subclass(*args_, **kwargs_)
        else:
            return EntityOut(*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_resident(self):
        return self.resident
    def set_resident(self, resident):
        self.resident = resident
    def get_govement_entity(self):
        return self.govement_entity
    def set_govement_entity(self, govement_entity):
        self.govement_entity = govement_entity
    def get_not_resident(self):
        return self.not_resident
    def set_not_resident(self, not_resident):
        self.not_resident = not_resident
    def has__content(self):
        if (
            self.resident is not None or
            self.govement_entity is not None or
            self.not_resident is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntityOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('EntityOut')
        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_ == 'EntityOut':
            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_='EntityOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='EntityOut', 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_='EntityOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntityOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.resident is not None:
            namespaceprefix_ = self.resident_nsprefix_ + ':' if (UseCapturedNS_ and self.resident_nsprefix_) else ''
            self.resident.export(outfile, level, namespaceprefix_, namespacedef_='', name_='resident', pretty_print=pretty_print)
        if self.govement_entity is not None:
            namespaceprefix_ = self.govement_entity_nsprefix_ + ':' if (UseCapturedNS_ and self.govement_entity_nsprefix_) else ''
            self.govement_entity.export(outfile, level, namespaceprefix_, namespacedef_='', name_='govement_entity', pretty_print=pretty_print)
        if self.not_resident is not None:
            namespaceprefix_ = self.not_resident_nsprefix_ + ':' if (UseCapturedNS_ and self.not_resident_nsprefix_) else ''
            self.not_resident.export(outfile, level, namespaceprefix_, namespacedef_='', name_='not_resident', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'resident':
            obj_ = ResidentOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.resident = obj_
            obj_.original_tagname_ = 'resident'
        elif nodeName_ == 'govement_entity':
            obj_ = GovementEntity.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.govement_entity = obj_
            obj_.original_tagname_ = 'govement_entity'
        elif nodeName_ == 'not_resident':
            obj_ = NotResidentOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.not_resident = obj_
            obj_.original_tagname_ = 'not_resident'
# end class EntityOut


class LegalEntityUL(GeneratedsSuper):
    """LegalEntityUL -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    (
    р
    о
    с
    с
    и
    й
    с
    к
    о
    е
    ,
    и
    н
    о
    с
    т
    р
    а
    н
    н
    о
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    )
    entity -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    (
    р
    о
    с
    с
    и
    й
    с
    к
    о
    е
    ,
    и
    н
    о
    с
    т
    р
    а
    н
    н
    о
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, entity=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.entity = entity
        self.entity_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LegalEntityUL)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LegalEntityUL.subclass:
            return LegalEntityUL.subclass(*args_, **kwargs_)
        else:
            return LegalEntityUL(*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_entity(self):
        return self.entity
    def set_entity(self, entity):
        self.entity = entity
    def has__content(self):
        if (
            self.entity is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LegalEntityUL', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LegalEntityUL')
        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_ == 'LegalEntityUL':
            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_='LegalEntityUL')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LegalEntityUL', 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_='LegalEntityUL'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LegalEntityUL', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.entity is not None:
            namespaceprefix_ = self.entity_nsprefix_ + ':' if (UseCapturedNS_ and self.entity_nsprefix_) else ''
            self.entity.export(outfile, level, namespaceprefix_, namespacedef_='', name_='entity', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'entity':
            obj_ = EntityUL.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.entity = obj_
            obj_.original_tagname_ = 'entity'
# end class LegalEntityUL


class EntityUL(GeneratedsSuper):
    """EntityUL -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    (
    р
    о
    с
    с
    и
    й
    с
    к
    о
    е
    ,
    и
    н
    о
    с
    т
    р
    а
    н
    н
    о
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    )
    resident -- Р
    о
    с
    с
    и
    й
    с
    к
    о
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    not_resident -- И
    н
    о
    с
    т
    р
    а
    н
    н
    о
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, resident=None, not_resident=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.resident = resident
        self.resident_nsprefix_ = None
        self.not_resident = not_resident
        self.not_resident_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, EntityUL)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if EntityUL.subclass:
            return EntityUL.subclass(*args_, **kwargs_)
        else:
            return EntityUL(*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_resident(self):
        return self.resident
    def set_resident(self, resident):
        self.resident = resident
    def get_not_resident(self):
        return self.not_resident
    def set_not_resident(self, not_resident):
        self.not_resident = not_resident
    def has__content(self):
        if (
            self.resident is not None or
            self.not_resident is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntityUL', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('EntityUL')
        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_ == 'EntityUL':
            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_='EntityUL')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='EntityUL', 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_='EntityUL'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EntityUL', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.resident is not None:
            namespaceprefix_ = self.resident_nsprefix_ + ':' if (UseCapturedNS_ and self.resident_nsprefix_) else ''
            self.resident.export(outfile, level, namespaceprefix_, namespacedef_='', name_='resident', pretty_print=pretty_print)
        if self.not_resident is not None:
            namespaceprefix_ = self.not_resident_nsprefix_ + ':' if (UseCapturedNS_ and self.not_resident_nsprefix_) else ''
            self.not_resident.export(outfile, level, namespaceprefix_, namespacedef_='', name_='not_resident', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'resident':
            obj_ = ResidentOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.resident = obj_
            obj_.original_tagname_ = 'resident'
        elif nodeName_ == 'not_resident':
            obj_ = NotResidentOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.not_resident = obj_
            obj_.original_tagname_ = 'not_resident'
# end class EntityUL


class ResidentOut(GeneratedsSuper):
    """ResidentOut -- Р
    о
    с
    с
    и
    й
    с
    к
    о
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    incorporation_form -- О
    р
    г
    а
    н
    и
    з
    а
    ц
    и
    о
    н
    н
    о
    -
    п
    р
    а
    в
    о
    в
    а
    я
    ф
    о
    р
    м
    а
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    inn -- И
    Н
    Н
    ogrn -- О
    Г
    Р
    Н
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, incorporation_form=None, name=None, inn=None, ogrn=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.incorporation_form = incorporation_form
        self.incorporation_form_nsprefix_ = None
        self.name = name
        self.name_nsprefix_ = None
        self.inn = inn
        self.inn_nsprefix_ = None
        self.ogrn = ogrn
        self.ogrn_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ResidentOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ResidentOut.subclass:
            return ResidentOut.subclass(*args_, **kwargs_)
        else:
            return ResidentOut(*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_incorporation_form(self):
        return self.incorporation_form
    def set_incorporation_form(self, incorporation_form):
        self.incorporation_form = incorporation_form
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_inn(self):
        return self.inn
    def set_inn(self, inn):
        self.inn = inn
    def get_ogrn(self):
        return self.ogrn
    def set_ogrn(self, ogrn):
        self.ogrn = ogrn
    def has__content(self):
        if (
            self.incorporation_form is not None or
            self.name is not None or
            self.inn is not None or
            self.ogrn is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ResidentOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ResidentOut')
        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_ == 'ResidentOut':
            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_='ResidentOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ResidentOut', 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_='ResidentOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ResidentOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.incorporation_form is not None:
            namespaceprefix_ = self.incorporation_form_nsprefix_ + ':' if (UseCapturedNS_ and self.incorporation_form_nsprefix_) else ''
            self.incorporation_form.export(outfile, level, namespaceprefix_, namespacedef_='', name_='incorporation_form', pretty_print=pretty_print)
        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.inn is not None:
            namespaceprefix_ = self.inn_nsprefix_ + ':' if (UseCapturedNS_ and self.inn_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sinn>%s</%sinn>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.inn), input_name='inn')), namespaceprefix_ , eol_))
        if self.ogrn is not None:
            namespaceprefix_ = self.ogrn_nsprefix_ + ':' if (UseCapturedNS_ and self.ogrn_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sogrn>%s</%sogrn>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.ogrn), input_name='ogrn')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'incorporation_form':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.incorporation_form = obj_
            obj_.original_tagname_ = 'incorporation_form'
        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_ == 'inn':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'inn')
            value_ = self.gds_validate_string(value_, node, 'inn')
            self.inn = value_
            self.inn_nsprefix_ = child_.prefix
        elif nodeName_ == 'ogrn':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'ogrn')
            value_ = self.gds_validate_string(value_, node, 'ogrn')
            self.ogrn = value_
            self.ogrn_nsprefix_ = child_.prefix
# end class ResidentOut


class NotResidentOut(GeneratedsSuper):
    """NotResidentOut -- И
    н
    о
    с
    т
    р
    а
    н
    н
    о
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    incorporation_form -- О
    р
    г
    а
    н
    и
    з
    а
    ц
    и
    о
    н
    н
    о
    -
    п
    р
    а
    в
    о
    в
    а
    я
    ф
    о
    р
    м
    а
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    incorporate_country -- С
    т
    р
    а
    н
    а
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    (
    и
    н
    к
    о
    р
    п
    о
    р
    а
    ц
    и
    и
    )
    registration_number -- Р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    о
    н
    н
    ы
    й
    н
    о
    м
    е
    р
    date_state_reg -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    registration_organ -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    р
    е
    г
    и
    с
    т
    р
    и
    р
    у
    ю
    щ
    е
    г
    о
    о
    р
    г
    а
    н
    а
    reg_address_subject -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    н
    а
    х
    о
    ж
    д
    е
    н
    и
    е
    )
    в
    с
    т
    р
    а
    н
    е
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    (
    и
    н
    к
    о
    р
    п
    о
    р
    а
    ц
    и
    и
    )
    inn -- И
    Н
    Н
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, incorporation_form=None, name=None, incorporate_country=None, registration_number=None, date_state_reg=None, registration_organ=None, reg_address_subject=None, inn=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.incorporation_form = incorporation_form
        self.incorporation_form_nsprefix_ = None
        self.name = name
        self.name_nsprefix_ = None
        self.incorporate_country = incorporate_country
        self.incorporate_country_nsprefix_ = None
        self.registration_number = registration_number
        self.registration_number_nsprefix_ = None
        if isinstance(date_state_reg, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_state_reg, '%Y-%m-%d').date()
        else:
            initvalue_ = date_state_reg
        self.date_state_reg = initvalue_
        self.date_state_reg_nsprefix_ = None
        self.registration_organ = registration_organ
        self.registration_organ_nsprefix_ = None
        self.reg_address_subject = reg_address_subject
        self.validate_MultiLiner(self.reg_address_subject)
        self.reg_address_subject_nsprefix_ = None
        self.inn = inn
        self.inn_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, NotResidentOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if NotResidentOut.subclass:
            return NotResidentOut.subclass(*args_, **kwargs_)
        else:
            return NotResidentOut(*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_incorporation_form(self):
        return self.incorporation_form
    def set_incorporation_form(self, incorporation_form):
        self.incorporation_form = incorporation_form
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_incorporate_country(self):
        return self.incorporate_country
    def set_incorporate_country(self, incorporate_country):
        self.incorporate_country = incorporate_country
    def get_registration_number(self):
        return self.registration_number
    def set_registration_number(self, registration_number):
        self.registration_number = registration_number
    def get_date_state_reg(self):
        return self.date_state_reg
    def set_date_state_reg(self, date_state_reg):
        self.date_state_reg = date_state_reg
    def get_registration_organ(self):
        return self.registration_organ
    def set_registration_organ(self, registration_organ):
        self.registration_organ = registration_organ
    def get_reg_address_subject(self):
        return self.reg_address_subject
    def set_reg_address_subject(self, reg_address_subject):
        self.reg_address_subject = reg_address_subject
    def get_inn(self):
        return self.inn
    def set_inn(self, inn):
        self.inn = inn
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.incorporation_form is not None or
            self.name is not None or
            self.incorporate_country is not None or
            self.registration_number is not None or
            self.date_state_reg is not None or
            self.registration_organ is not None or
            self.reg_address_subject is not None or
            self.inn is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NotResidentOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('NotResidentOut')
        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_ == 'NotResidentOut':
            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_='NotResidentOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NotResidentOut', 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_='NotResidentOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NotResidentOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.incorporation_form is not None:
            namespaceprefix_ = self.incorporation_form_nsprefix_ + ':' if (UseCapturedNS_ and self.incorporation_form_nsprefix_) else ''
            self.incorporation_form.export(outfile, level, namespaceprefix_, namespacedef_='', name_='incorporation_form', pretty_print=pretty_print)
        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.incorporate_country is not None:
            namespaceprefix_ = self.incorporate_country_nsprefix_ + ':' if (UseCapturedNS_ and self.incorporate_country_nsprefix_) else ''
            self.incorporate_country.export(outfile, level, namespaceprefix_, namespacedef_='', name_='incorporate_country', pretty_print=pretty_print)
        if self.registration_number is not None:
            namespaceprefix_ = self.registration_number_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_number>%s</%sregistration_number>%s' % (namespaceprefix_ , self.gds_format_integer(self.registration_number, input_name='registration_number'), namespaceprefix_ , eol_))
        if self.date_state_reg is not None:
            namespaceprefix_ = self.date_state_reg_nsprefix_ + ':' if (UseCapturedNS_ and self.date_state_reg_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_state_reg>%s</%sdate_state_reg>%s' % (namespaceprefix_ , self.gds_format_date(self.date_state_reg, input_name='date_state_reg'), namespaceprefix_ , eol_))
        if self.registration_organ is not None:
            namespaceprefix_ = self.registration_organ_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_organ_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_organ>%s</%sregistration_organ>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.registration_organ), input_name='registration_organ')), namespaceprefix_ , eol_))
        if self.reg_address_subject is not None:
            namespaceprefix_ = self.reg_address_subject_nsprefix_ + ':' if (UseCapturedNS_ and self.reg_address_subject_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreg_address_subject>%s</%sreg_address_subject>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.reg_address_subject), input_name='reg_address_subject')), namespaceprefix_ , eol_))
        if self.inn is not None:
            namespaceprefix_ = self.inn_nsprefix_ + ':' if (UseCapturedNS_ and self.inn_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sinn>%s</%sinn>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.inn), input_name='inn')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'incorporation_form':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.incorporation_form = obj_
            obj_.original_tagname_ = 'incorporation_form'
        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_ == 'incorporate_country':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.incorporate_country = obj_
            obj_.original_tagname_ = 'incorporate_country'
        elif nodeName_ == 'registration_number' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'registration_number')
            ival_ = self.gds_validate_integer(ival_, node, 'registration_number')
            self.registration_number = ival_
            self.registration_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'date_state_reg':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_state_reg = dval_
            self.date_state_reg_nsprefix_ = child_.prefix
        elif nodeName_ == 'registration_organ':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'registration_organ')
            value_ = self.gds_validate_string(value_, node, 'registration_organ')
            self.registration_organ = value_
            self.registration_organ_nsprefix_ = child_.prefix
        elif nodeName_ == 'reg_address_subject':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'reg_address_subject')
            value_ = self.gds_validate_string(value_, node, 'reg_address_subject')
            self.reg_address_subject = value_
            self.reg_address_subject_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.reg_address_subject)
        elif nodeName_ == 'inn':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'inn')
            value_ = self.gds_validate_string(value_, node, 'inn')
            self.inn = value_
            self.inn_nsprefix_ = child_.prefix
# end class NotResidentOut


class GovementEntity(GeneratedsSuper):
    """GovementEntity -- О
    р
    г
    а
    н
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    в
    л
    а
    с
    т
    и
    ,
    о
    р
    г
    а
    н
    м
    е
    с
    т
    н
    о
    г
    о
    с
    а
    м
    о
    у
    п
    р
    а
    в
    л
    е
    н
    и
    я
    ,
    и
    н
    о
    й
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    й
    о
    р
    г
    а
    н
    full_name -- П
    о
    л
    н
    о
    е
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    inn -- И
    Н
    Н
    ogrn -- О
    Г
    Р
    Н
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, full_name=None, inn=None, ogrn=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.full_name = full_name
        self.full_name_nsprefix_ = None
        self.inn = inn
        self.inn_nsprefix_ = None
        self.ogrn = ogrn
        self.ogrn_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, GovementEntity)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if GovementEntity.subclass:
            return GovementEntity.subclass(*args_, **kwargs_)
        else:
            return GovementEntity(*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_full_name(self):
        return self.full_name
    def set_full_name(self, full_name):
        self.full_name = full_name
    def get_inn(self):
        return self.inn
    def set_inn(self, inn):
        self.inn = inn
    def get_ogrn(self):
        return self.ogrn
    def set_ogrn(self, ogrn):
        self.ogrn = ogrn
    def has__content(self):
        if (
            self.full_name is not None or
            self.inn is not None or
            self.ogrn is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='GovementEntity', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('GovementEntity')
        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_ == 'GovementEntity':
            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_='GovementEntity')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GovementEntity', 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_='GovementEntity'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='GovementEntity', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.full_name is not None:
            namespaceprefix_ = self.full_name_nsprefix_ + ':' if (UseCapturedNS_ and self.full_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfull_name>%s</%sfull_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.full_name), input_name='full_name')), namespaceprefix_ , eol_))
        if self.inn is not None:
            namespaceprefix_ = self.inn_nsprefix_ + ':' if (UseCapturedNS_ and self.inn_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sinn>%s</%sinn>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.inn), input_name='inn')), namespaceprefix_ , eol_))
        if self.ogrn is not None:
            namespaceprefix_ = self.ogrn_nsprefix_ + ':' if (UseCapturedNS_ and self.ogrn_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sogrn>%s</%sogrn>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.ogrn), input_name='ogrn')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'full_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'full_name')
            value_ = self.gds_validate_string(value_, node, 'full_name')
            self.full_name = value_
            self.full_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'inn':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'inn')
            value_ = self.gds_validate_string(value_, node, 'inn')
            self.inn = value_
            self.inn_nsprefix_ = child_.prefix
        elif nodeName_ == 'ogrn':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'ogrn')
            value_ = self.gds_validate_string(value_, node, 'ogrn')
            self.ogrn = value_
            self.ogrn_nsprefix_ = child_.prefix
# end class GovementEntity


class InvestmentUnitOwnerOut(GeneratedsSuper):
    """InvestmentUnitOwnerOut -- В
    л
    а
    д
    е
    л
    ь
    ц
    ы
    и
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    ы
    х
    п
    а
    е
    в
    investment_unit_name -- Н
    а
    з
    в
    а
    н
    и
    е
    (
    и
    н
    д
    и
    в
    и
    д
    у
    а
    л
    ь
    н
    о
    е
    о
    б
    о
    з
    н
    а
    ч
    е
    н
    и
    е
    ),
    и
    д
    е
    н
    т
    и
    ф
    и
    ц
    и
    р
    у
    ю
    щ
    е
    е
    п
    а
    е
    в
    о
    й
    и
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    ы
    й
    ф
    о
    н
    д
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, investment_unit_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.investment_unit_name = investment_unit_name
        self.investment_unit_name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, InvestmentUnitOwnerOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if InvestmentUnitOwnerOut.subclass:
            return InvestmentUnitOwnerOut.subclass(*args_, **kwargs_)
        else:
            return InvestmentUnitOwnerOut(*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_investment_unit_name(self):
        return self.investment_unit_name
    def set_investment_unit_name(self, investment_unit_name):
        self.investment_unit_name = investment_unit_name
    def has__content(self):
        if (
            self.investment_unit_name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='InvestmentUnitOwnerOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('InvestmentUnitOwnerOut')
        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_ == 'InvestmentUnitOwnerOut':
            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_='InvestmentUnitOwnerOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='InvestmentUnitOwnerOut', 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_='InvestmentUnitOwnerOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='InvestmentUnitOwnerOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.investment_unit_name is not None:
            namespaceprefix_ = self.investment_unit_name_nsprefix_ + ':' if (UseCapturedNS_ and self.investment_unit_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sinvestment_unit_name>%s</%sinvestment_unit_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.investment_unit_name), input_name='investment_unit_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'investment_unit_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'investment_unit_name')
            value_ = self.gds_validate_string(value_, node, 'investment_unit_name')
            self.investment_unit_name = value_
            self.investment_unit_name_nsprefix_ = child_.prefix
# end class InvestmentUnitOwnerOut


class BondsHoldersOut(GeneratedsSuper):
    """BondsHoldersOut -- В
    л
    а
    д
    е
    л
    ь
    ц
    ы
    о
    б
    л
    и
    г
    а
    ц
    и
    й
    bonds_number -- Г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    ы
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    о
    н
    н
    ы
    й
    н
    о
    м
    е
    р
    в
    ы
    п
    у
    с
    к
    а
    о
    б
    л
    и
    г
    а
    ц
    и
    й
    issue_date -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    н
    о
    м
    е
    р
    а
    в
    ы
    п
    у
    с
    к
    а
    о
    б
    л
    и
    г
    а
    ц
    и
    й
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, bonds_number=None, issue_date=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.bonds_number = bonds_number
        self.bonds_number_nsprefix_ = None
        if isinstance(issue_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(issue_date, '%Y-%m-%d').date()
        else:
            initvalue_ = issue_date
        self.issue_date = initvalue_
        self.issue_date_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, BondsHoldersOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if BondsHoldersOut.subclass:
            return BondsHoldersOut.subclass(*args_, **kwargs_)
        else:
            return BondsHoldersOut(*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_bonds_number(self):
        return self.bonds_number
    def set_bonds_number(self, bonds_number):
        self.bonds_number = bonds_number
    def get_issue_date(self):
        return self.issue_date
    def set_issue_date(self, issue_date):
        self.issue_date = issue_date
    def has__content(self):
        if (
            self.bonds_number is not None or
            self.issue_date is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BondsHoldersOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('BondsHoldersOut')
        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_ == 'BondsHoldersOut':
            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_='BondsHoldersOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BondsHoldersOut', 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_='BondsHoldersOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='BondsHoldersOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.bonds_number is not None:
            namespaceprefix_ = self.bonds_number_nsprefix_ + ':' if (UseCapturedNS_ and self.bonds_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbonds_number>%s</%sbonds_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.bonds_number), input_name='bonds_number')), namespaceprefix_ , eol_))
        if self.issue_date is not None:
            namespaceprefix_ = self.issue_date_nsprefix_ + ':' if (UseCapturedNS_ and self.issue_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sissue_date>%s</%sissue_date>%s' % (namespaceprefix_ , self.gds_format_date(self.issue_date, input_name='issue_date'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'bonds_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'bonds_number')
            value_ = self.gds_validate_string(value_, node, 'bonds_number')
            self.bonds_number = value_
            self.bonds_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'issue_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.issue_date = dval_
            self.issue_date_nsprefix_ = child_.prefix
# end class BondsHoldersOut


class CertificatesHoldersOut(GeneratedsSuper):
    """CertificatesHoldersOut -- В
    л
    а
    д
    е
    л
    ь
    ц
    ы
    и
    п
    о
    т
    е
    ч
    н
    ы
    х
    с
    е
    р
    т
    и
    ф
    и
    к
    а
    т
    о
    в
    у
    ч
    а
    с
    т
    и
    я
    certificate_name -- И
    н
    д
    и
    в
    и
    д
    у
    а
    л
    ь
    н
    о
    е
    о
    б
    о
    з
    н
    а
    ч
    е
    н
    и
    е
    ,
    и
    д
    е
    н
    т
    и
    ф
    и
    ц
    и
    р
    у
    ю
    щ
    е
    е
    и
    п
    о
    т
    е
    ч
    н
    ы
    е
    с
    е
    р
    т
    и
    ф
    и
    к
    а
    т
    ы
    у
    ч
    а
    с
    т
    и
    я
    ,
    в
    и
    н
    т
    е
    р
    е
    с
    а
    х
    в
    л
    а
    д
    е
    л
    ь
    ц
    е
    в
    к
    о
    т
    о
    р
    ы
    х
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    я
    е
    т
    с
    я
    д
    о
    в
    е
    р
    и
    т
    е
    л
    ь
    н
    о
    е
    у
    п
    р
    а
    в
    л
    е
    н
    и
    е
    т
    а
    к
    и
    м
    и
    п
    о
    т
    е
    ч
    н
    ы
    м
    п
    о
    к
    р
    ы
    т
    и
    е
    м
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, certificate_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.certificate_name = certificate_name
        self.certificate_name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CertificatesHoldersOut)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CertificatesHoldersOut.subclass:
            return CertificatesHoldersOut.subclass(*args_, **kwargs_)
        else:
            return CertificatesHoldersOut(*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_certificate_name(self):
        return self.certificate_name
    def set_certificate_name(self, certificate_name):
        self.certificate_name = certificate_name
    def has__content(self):
        if (
            self.certificate_name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CertificatesHoldersOut', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CertificatesHoldersOut')
        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_ == 'CertificatesHoldersOut':
            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_='CertificatesHoldersOut')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CertificatesHoldersOut', 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_='CertificatesHoldersOut'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CertificatesHoldersOut', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.certificate_name is not None:
            namespaceprefix_ = self.certificate_name_nsprefix_ + ':' if (UseCapturedNS_ and self.certificate_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scertificate_name>%s</%scertificate_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.certificate_name), input_name='certificate_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'certificate_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'certificate_name')
            value_ = self.gds_validate_string(value_, node, 'certificate_name')
            self.certificate_name = value_
            self.certificate_name_nsprefix_ = child_.prefix
# end class CertificatesHoldersOut


class Partnership(GeneratedsSuper):
    """Partnership -- И
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    о
    е
    т
    о
    в
    а
    р
    и
    щ
    е
    с
    т
    в
    о
    partnership_participants -- У
    ч
    а
    с
    т
    н
    и
    к
    и
    д
    о
    г
    о
    в
    о
    р
    а
    и
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    о
    г
    о
    т
    о
    в
    а
    р
    и
    щ
    е
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, partnership_participants=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.partnership_participants = partnership_participants
        self.partnership_participants_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Partnership)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Partnership.subclass:
            return Partnership.subclass(*args_, **kwargs_)
        else:
            return Partnership(*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_partnership_participants(self):
        return self.partnership_participants
    def set_partnership_participants(self, partnership_participants):
        self.partnership_participants = partnership_participants
    def has__content(self):
        if (
            self.partnership_participants is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Partnership', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Partnership')
        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_ == 'Partnership':
            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_='Partnership')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Partnership', 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_='Partnership'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Partnership', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.partnership_participants is not None:
            namespaceprefix_ = self.partnership_participants_nsprefix_ + ':' if (UseCapturedNS_ and self.partnership_participants_nsprefix_) else ''
            self.partnership_participants.export(outfile, level, namespaceprefix_, namespacedef_='', name_='partnership_participants', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'partnership_participants':
            obj_ = partnership_participantsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.partnership_participants = obj_
            obj_.original_tagname_ = 'partnership_participants'
# end class Partnership


class PartnershipParticipant(GeneratedsSuper):
    """PartnershipParticipant -- У
    ч
    а
    с
    т
    н
    и
    к
    д
    о
    г
    о
    в
    о
    р
    а
    и
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    о
    г
    о
    т
    о
    в
    а
    р
    и
    щ
    е
    с
    т
    в
    а
    legal_entity -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    (
    р
    о
    с
    с
    и
    й
    с
    к
    о
    е
    ,
    и
    н
    о
    с
    т
    р
    а
    н
    н
    о
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    )
    contacts -- К
    о
    н
    т
    а
    к
    т
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, legal_entity=None, contacts=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.legal_entity = legal_entity
        self.legal_entity_nsprefix_ = None
        self.contacts = contacts
        self.contacts_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PartnershipParticipant)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PartnershipParticipant.subclass:
            return PartnershipParticipant.subclass(*args_, **kwargs_)
        else:
            return PartnershipParticipant(*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_legal_entity(self):
        return self.legal_entity
    def set_legal_entity(self, legal_entity):
        self.legal_entity = legal_entity
    def get_contacts(self):
        return self.contacts
    def set_contacts(self, contacts):
        self.contacts = contacts
    def has__content(self):
        if (
            self.legal_entity is not None or
            self.contacts is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PartnershipParticipant', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PartnershipParticipant')
        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_ == 'PartnershipParticipant':
            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_='PartnershipParticipant')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PartnershipParticipant', 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_='PartnershipParticipant'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PartnershipParticipant', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.legal_entity is not None:
            namespaceprefix_ = self.legal_entity_nsprefix_ + ':' if (UseCapturedNS_ and self.legal_entity_nsprefix_) else ''
            self.legal_entity.export(outfile, level, namespaceprefix_, namespacedef_='', name_='legal_entity', pretty_print=pretty_print)
        if self.contacts is not None:
            namespaceprefix_ = self.contacts_nsprefix_ + ':' if (UseCapturedNS_ and self.contacts_nsprefix_) else ''
            self.contacts.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contacts', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'legal_entity':
            obj_ = LegalEntityUL.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.legal_entity = obj_
            obj_.original_tagname_ = 'legal_entity'
        elif nodeName_ == 'contacts':
            obj_ = Contacts.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contacts = obj_
            obj_.original_tagname_ = 'contacts'
# end class PartnershipParticipant


class EquityParticipantsInfo(GeneratedsSuper):
    """EquityParticipantsInfo -- У
    ч
    а
    с
    т
    н
    и
    к
    и
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    п
    о
    д
    о
    г
    о
    в
    о
    р
    а
    м
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    equity_participants -- У
    ч
    а
    с
    т
    н
    и
    к
    и
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, equity_participants=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.equity_participants = equity_participants
        self.equity_participants_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, EquityParticipantsInfo)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if EquityParticipantsInfo.subclass:
            return EquityParticipantsInfo.subclass(*args_, **kwargs_)
        else:
            return EquityParticipantsInfo(*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_equity_participants(self):
        return self.equity_participants
    def set_equity_participants(self, equity_participants):
        self.equity_participants = equity_participants
    def has__content(self):
        if (
            self.equity_participants is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EquityParticipantsInfo', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('EquityParticipantsInfo')
        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_ == 'EquityParticipantsInfo':
            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_='EquityParticipantsInfo')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='EquityParticipantsInfo', 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_='EquityParticipantsInfo'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='EquityParticipantsInfo', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.equity_participants is not None:
            namespaceprefix_ = self.equity_participants_nsprefix_ + ':' if (UseCapturedNS_ and self.equity_participants_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sequity_participants>%s</%sequity_participants>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.equity_participants), input_name='equity_participants')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'equity_participants':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'equity_participants')
            value_ = self.gds_validate_string(value_, node, 'equity_participants')
            self.equity_participants = value_
            self.equity_participants_nsprefix_ = child_.prefix
# end class EquityParticipantsInfo


class NotEquityParticipantsInfo(GeneratedsSuper):
    """NotEquityParticipantsInfo -- У
    ч
    а
    с
    т
    н
    и
    к
    и
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    п
    о
    д
    о
    г
    о
    в
    о
    р
    а
    м
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    ,
    к
    о
    т
    о
    р
    ы
    м
    н
    е
    п
    е
    р
    е
    д
    а
    н
    ы
    о
    б
    ъ
    е
    к
    т
    ы
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    not_equity_participants -- У
    ч
    а
    с
    т
    н
    и
    к
    и
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    п
    о
    д
    о
    г
    о
    в
    о
    р
    а
    м
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    ,
    к
    о
    т
    о
    р
    ы
    м
    н
    е
    п
    е
    р
    е
    д
    а
    н
    ы
    о
    б
    ъ
    е
    к
    т
    ы
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, not_equity_participants=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.not_equity_participants = not_equity_participants
        self.not_equity_participants_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, NotEquityParticipantsInfo)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if NotEquityParticipantsInfo.subclass:
            return NotEquityParticipantsInfo.subclass(*args_, **kwargs_)
        else:
            return NotEquityParticipantsInfo(*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_not_equity_participants(self):
        return self.not_equity_participants
    def set_not_equity_participants(self, not_equity_participants):
        self.not_equity_participants = not_equity_participants
    def has__content(self):
        if (
            self.not_equity_participants is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NotEquityParticipantsInfo', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('NotEquityParticipantsInfo')
        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_ == 'NotEquityParticipantsInfo':
            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_='NotEquityParticipantsInfo')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NotEquityParticipantsInfo', 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_='NotEquityParticipantsInfo'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NotEquityParticipantsInfo', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.not_equity_participants is not None:
            namespaceprefix_ = self.not_equity_participants_nsprefix_ + ':' if (UseCapturedNS_ and self.not_equity_participants_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snot_equity_participants>%s</%snot_equity_participants>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.not_equity_participants), input_name='not_equity_participants')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'not_equity_participants':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'not_equity_participants')
            value_ = self.gds_validate_string(value_, node, 'not_equity_participants')
            self.not_equity_participants = value_
            self.not_equity_participants_nsprefix_ = child_.prefix
# end class NotEquityParticipantsInfo


class AparthouseOwners(GeneratedsSuper):
    """AparthouseOwners -- С
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    в
    м
    н
    о
    г
    о
    к
    в
    а
    р
    т
    и
    р
    н
    о
    м
    д
    о
    м
    е
    aparthouse_owners_name -- С
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    в
    м
    н
    о
    г
    о
    к
    в
    а
    р
    т
    и
    р
    н
    о
    м
    д
    о
    м
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, aparthouse_owners_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.aparthouse_owners_name = aparthouse_owners_name
        self.aparthouse_owners_name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AparthouseOwners)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AparthouseOwners.subclass:
            return AparthouseOwners.subclass(*args_, **kwargs_)
        else:
            return AparthouseOwners(*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_aparthouse_owners_name(self):
        return self.aparthouse_owners_name
    def set_aparthouse_owners_name(self, aparthouse_owners_name):
        self.aparthouse_owners_name = aparthouse_owners_name
    def has__content(self):
        if (
            self.aparthouse_owners_name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AparthouseOwners', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AparthouseOwners')
        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_ == 'AparthouseOwners':
            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_='AparthouseOwners')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AparthouseOwners', 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_='AparthouseOwners'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AparthouseOwners', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.aparthouse_owners_name is not None:
            namespaceprefix_ = self.aparthouse_owners_name_nsprefix_ + ':' if (UseCapturedNS_ and self.aparthouse_owners_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%saparthouse_owners_name>%s</%saparthouse_owners_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.aparthouse_owners_name), input_name='aparthouse_owners_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'aparthouse_owners_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'aparthouse_owners_name')
            value_ = self.gds_validate_string(value_, node, 'aparthouse_owners_name')
            self.aparthouse_owners_name = value_
            self.aparthouse_owners_name_nsprefix_ = child_.prefix
# end class AparthouseOwners


class PublicServitude(GeneratedsSuper):
    """PublicServitude -- П
    у
    б
    л
    и
    ч
    н
    ы
    й
    с
    е
    р
    в
    и
    т
    у
    т
    public -- П
    у
    б
    л
    и
    ч
    н
    ы
    й
    с
    е
    р
    в
    и
    т
    у
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, public=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.public = public
        self.public_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PublicServitude)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PublicServitude.subclass:
            return PublicServitude.subclass(*args_, **kwargs_)
        else:
            return PublicServitude(*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_public(self):
        return self.public
    def set_public(self, public):
        self.public = public
    def has__content(self):
        if (
            self.public is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PublicServitude', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PublicServitude')
        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_ == 'PublicServitude':
            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_='PublicServitude')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PublicServitude', 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_='PublicServitude'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PublicServitude', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.public is not None:
            namespaceprefix_ = self.public_nsprefix_ + ':' if (UseCapturedNS_ and self.public_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spublic>%s</%spublic>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.public), input_name='public')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'public':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'public')
            value_ = self.gds_validate_string(value_, node, 'public')
            self.public = value_
            self.public_nsprefix_ = child_.prefix
# end class PublicServitude


class Undefined(GeneratedsSuper):
    """Undefined -- Н
    е
    о
    п
    р
    е
    д
    е
    л
    е
    н
    о
    (
    Л
    и
    ц
    о
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    о
    г
    о
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    )
    undefined -- Н
    е
    о
    п
    р
    е
    д
    е
    л
    е
    н
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, undefined=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.undefined = undefined
        self.undefined_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Undefined)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Undefined.subclass:
            return Undefined.subclass(*args_, **kwargs_)
        else:
            return Undefined(*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_undefined(self):
        return self.undefined
    def set_undefined(self, undefined):
        self.undefined = undefined
    def has__content(self):
        if (
            self.undefined is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Undefined', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Undefined')
        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_ == 'Undefined':
            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_='Undefined')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Undefined', 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_='Undefined'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Undefined', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.undefined is not None:
            namespaceprefix_ = self.undefined_nsprefix_ + ':' if (UseCapturedNS_ and self.undefined_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sundefined>%s</%sundefined>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.undefined), input_name='undefined')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'undefined':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'undefined')
            value_ = self.gds_validate_string(value_, node, 'undefined')
            self.undefined = value_
            self.undefined_nsprefix_ = child_.prefix
# end class Undefined


class Contacts(GeneratedsSuper):
    """Contacts -- К
    о
    н
    т
    а
    к
    т
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    email -- А
    д
    р
    е
    с
    э
    л
    е
    к
    т
    р
    о
    н
    н
    о
    й
    п
    о
    ч
    т
    ы
    mailing_addess -- П
    о
    ч
    т
    о
    в
    ы
    й
    а
    д
    р
    е
    с
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, email=None, mailing_addess=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.email = email
        self.email_nsprefix_ = None
        self.mailing_addess = mailing_addess
        self.validate_MultiLiner(self.mailing_addess)
        self.mailing_addess_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Contacts)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Contacts.subclass:
            return Contacts.subclass(*args_, **kwargs_)
        else:
            return Contacts(*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_email(self):
        return self.email
    def set_email(self, email):
        self.email = email
    def get_mailing_addess(self):
        return self.mailing_addess
    def set_mailing_addess(self, mailing_addess):
        self.mailing_addess = mailing_addess
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.email is not None or
            self.mailing_addess is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Contacts', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Contacts')
        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_ == 'Contacts':
            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_='Contacts')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Contacts', 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_='Contacts'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Contacts', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.email is not None:
            namespaceprefix_ = self.email_nsprefix_ + ':' if (UseCapturedNS_ and self.email_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%semail>%s</%semail>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.email), input_name='email')), namespaceprefix_ , eol_))
        if self.mailing_addess is not None:
            namespaceprefix_ = self.mailing_addess_nsprefix_ + ':' if (UseCapturedNS_ and self.mailing_addess_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%smailing_addess>%s</%smailing_addess>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.mailing_addess), input_name='mailing_addess')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'email':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'email')
            value_ = self.gds_validate_string(value_, node, 'email')
            self.email = value_
            self.email_nsprefix_ = child_.prefix
        elif nodeName_ == 'mailing_addess':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'mailing_addess')
            value_ = self.gds_validate_string(value_, node, 'mailing_addess')
            self.mailing_addess = value_
            self.mailing_addess_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.mailing_addess)
# end class Contacts


class PublicFormations(GeneratedsSuper):
    """PublicFormations -- П
    у
    б
    л
    и
    ч
    н
    о
    -
    п
    р
    а
    в
    о
    в
    о
    е
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    е
    public_formation_type -- Т
    и
    п
    п
    у
    б
    л
    и
    ч
    н
    о
    -
    п
    р
    а
    в
    о
    в
    о
    г
    о
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, public_formation_type=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.public_formation_type = public_formation_type
        self.public_formation_type_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PublicFormations)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PublicFormations.subclass:
            return PublicFormations.subclass(*args_, **kwargs_)
        else:
            return PublicFormations(*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_public_formation_type(self):
        return self.public_formation_type
    def set_public_formation_type(self, public_formation_type):
        self.public_formation_type = public_formation_type
    def has__content(self):
        if (
            self.public_formation_type is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PublicFormations', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PublicFormations')
        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_ == 'PublicFormations':
            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_='PublicFormations')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PublicFormations', 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_='PublicFormations'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PublicFormations', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.public_formation_type is not None:
            namespaceprefix_ = self.public_formation_type_nsprefix_ + ':' if (UseCapturedNS_ and self.public_formation_type_nsprefix_) else ''
            self.public_formation_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='public_formation_type', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'public_formation_type':
            obj_ = PublicFormationType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.public_formation_type = obj_
            obj_.original_tagname_ = 'public_formation_type'
# end class PublicFormations


class PublicFormationType(GeneratedsSuper):
    """PublicFormationType -- Т
    и
    п
    п
    у
    б
    л
    и
    ч
    н
    о
    -
    п
    р
    а
    в
    о
    в
    о
    г
    о
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    я
    foreign_public -- И
    н
    о
    с
    т
    р
    а
    н
    н
    о
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    о
    union_state -- С
    о
    ю
    з
    н
    о
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    о
    russia -- Р
    о
    с
    с
    и
    й
    с
    к
    а
    я
    Ф
    е
    д
    е
    р
    а
    ц
    и
    я
    subject_of_rf -- С
    у
    б
    ъ
    е
    к
    т
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    municipality -- М
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    о
    е
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, foreign_public=None, union_state=None, russia=None, subject_of_rf=None, municipality=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.foreign_public = foreign_public
        self.foreign_public_nsprefix_ = None
        self.union_state = union_state
        self.union_state_nsprefix_ = None
        self.russia = russia
        self.russia_nsprefix_ = None
        self.subject_of_rf = subject_of_rf
        self.subject_of_rf_nsprefix_ = None
        self.municipality = municipality
        self.municipality_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PublicFormationType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PublicFormationType.subclass:
            return PublicFormationType.subclass(*args_, **kwargs_)
        else:
            return PublicFormationType(*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_foreign_public(self):
        return self.foreign_public
    def set_foreign_public(self, foreign_public):
        self.foreign_public = foreign_public
    def get_union_state(self):
        return self.union_state
    def set_union_state(self, union_state):
        self.union_state = union_state
    def get_russia(self):
        return self.russia
    def set_russia(self, russia):
        self.russia = russia
    def get_subject_of_rf(self):
        return self.subject_of_rf
    def set_subject_of_rf(self, subject_of_rf):
        self.subject_of_rf = subject_of_rf
    def get_municipality(self):
        return self.municipality
    def set_municipality(self, municipality):
        self.municipality = municipality
    def has__content(self):
        if (
            self.foreign_public is not None or
            self.union_state is not None or
            self.russia is not None or
            self.subject_of_rf is not None or
            self.municipality is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PublicFormationType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PublicFormationType')
        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_ == 'PublicFormationType':
            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_='PublicFormationType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PublicFormationType', 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_='PublicFormationType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='PublicFormationType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.foreign_public is not None:
            namespaceprefix_ = self.foreign_public_nsprefix_ + ':' if (UseCapturedNS_ and self.foreign_public_nsprefix_) else ''
            self.foreign_public.export(outfile, level, namespaceprefix_, namespacedef_='', name_='foreign_public', pretty_print=pretty_print)
        if self.union_state is not None:
            namespaceprefix_ = self.union_state_nsprefix_ + ':' if (UseCapturedNS_ and self.union_state_nsprefix_) else ''
            self.union_state.export(outfile, level, namespaceprefix_, namespacedef_='', name_='union_state', pretty_print=pretty_print)
        if self.russia is not None:
            namespaceprefix_ = self.russia_nsprefix_ + ':' if (UseCapturedNS_ and self.russia_nsprefix_) else ''
            self.russia.export(outfile, level, namespaceprefix_, namespacedef_='', name_='russia', pretty_print=pretty_print)
        if self.subject_of_rf is not None:
            namespaceprefix_ = self.subject_of_rf_nsprefix_ + ':' if (UseCapturedNS_ and self.subject_of_rf_nsprefix_) else ''
            self.subject_of_rf.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subject_of_rf', pretty_print=pretty_print)
        if self.municipality is not None:
            namespaceprefix_ = self.municipality_nsprefix_ + ':' if (UseCapturedNS_ and self.municipality_nsprefix_) else ''
            self.municipality.export(outfile, level, namespaceprefix_, namespacedef_='', name_='municipality', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'foreign_public':
            obj_ = ForeignPublic.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.foreign_public = obj_
            obj_.original_tagname_ = 'foreign_public'
        elif nodeName_ == 'union_state':
            obj_ = UnionState.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.union_state = obj_
            obj_.original_tagname_ = 'union_state'
        elif nodeName_ == 'russia':
            obj_ = Russia.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.russia = obj_
            obj_.original_tagname_ = 'russia'
        elif nodeName_ == 'subject_of_rf':
            obj_ = SubjectOfRF.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.subject_of_rf = obj_
            obj_.original_tagname_ = 'subject_of_rf'
        elif nodeName_ == 'municipality':
            obj_ = Municipality.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.municipality = obj_
            obj_.original_tagname_ = 'municipality'
# end class PublicFormationType


class ForeignPublic(GeneratedsSuper):
    """ForeignPublic -- П
    о
    л
    н
    о
    е
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    и
    н
    о
    с
    т
    р
    а
    н
    н
    о
    г
    о
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    а
    name -- П
    о
    л
    н
    о
    е
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    и
    н
    о
    с
    т
    р
    а
    н
    н
    о
    г
    о
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, 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.name = name
        self.name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ForeignPublic)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ForeignPublic.subclass:
            return ForeignPublic.subclass(*args_, **kwargs_)
        else:
            return ForeignPublic(*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 has__content(self):
        if (
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ForeignPublic', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ForeignPublic')
        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_ == 'ForeignPublic':
            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_='ForeignPublic')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ForeignPublic', 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_='ForeignPublic'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ForeignPublic', 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 ''
            self.name.export(outfile, level, namespaceprefix_, namespacedef_='', name_='name', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'name':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.name = obj_
            obj_.original_tagname_ = 'name'
# end class ForeignPublic


class UnionState(GeneratedsSuper):
    """UnionState -- С
    о
    ю
    з
    н
    о
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    о
    name -- С
    о
    ю
    з
    н
    о
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, 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.name = name
        self.name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, UnionState)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if UnionState.subclass:
            return UnionState.subclass(*args_, **kwargs_)
        else:
            return UnionState(*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 has__content(self):
        if (
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnionState', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnionState')
        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_ == 'UnionState':
            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_='UnionState')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnionState', 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_='UnionState'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnionState', 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):
        pass
    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 UnionState


class Russia(GeneratedsSuper):
    """Russia -- Р
    о
    с
    с
    и
    й
    с
    к
    а
    я
    Ф
    е
    д
    е
    р
    а
    ц
    и
    я
    name -- Р
    о
    с
    с
    и
    й
    с
    к
    а
    я
    Ф
    е
    д
    е
    р
    а
    ц
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, 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.name = name
        self.name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Russia)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Russia.subclass:
            return Russia.subclass(*args_, **kwargs_)
        else:
            return Russia(*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 has__content(self):
        if (
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Russia', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Russia')
        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_ == 'Russia':
            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_='Russia')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Russia', 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_='Russia'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Russia', 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 ''
            self.name.export(outfile, level, namespaceprefix_, namespacedef_='', name_='name', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'name':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.name = obj_
            obj_.original_tagname_ = 'name'
# end class Russia


class SubjectOfRF(GeneratedsSuper):
    """SubjectOfRF -- С
    у
    б
    ъ
    е
    к
    т
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    с
    у
    б
    ъ
    е
    к
    т
    а
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, 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.name = name
        self.name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SubjectOfRF)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SubjectOfRF.subclass:
            return SubjectOfRF.subclass(*args_, **kwargs_)
        else:
            return SubjectOfRF(*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 has__content(self):
        if (
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SubjectOfRF', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SubjectOfRF')
        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_ == 'SubjectOfRF':
            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_='SubjectOfRF')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SubjectOfRF', 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_='SubjectOfRF'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SubjectOfRF', 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 ''
            self.name.export(outfile, level, namespaceprefix_, namespacedef_='', name_='name', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'name':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.name = obj_
            obj_.original_tagname_ = 'name'
# end class SubjectOfRF


class Municipality(GeneratedsSuper):
    """Municipality -- М
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    о
    е
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    е
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    о
    г
    о
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, 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.name = name
        self.validate_MultiLiner(self.name)
        self.name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Municipality)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Municipality.subclass:
            return Municipality.subclass(*args_, **kwargs_)
        else:
            return Municipality(*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 validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Municipality', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Municipality')
        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_ == 'Municipality':
            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_='Municipality')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Municipality', 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_='Municipality'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Municipality', 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):
        pass
    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
            # validate type MultiLiner
            self.validate_MultiLiner(self.name)
# end class Municipality


class OtherSubject(GeneratedsSuper):
    """OtherSubject -- И
    н
    о
    й
    с
    у
    б
    ъ
    е
    к
    т
    name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    short_name -- К
    р
    а
    т
    к
    о
    е
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    comment -- К
    о
    м
    м
    е
    н
    т
    а
    р
    и
    й
    print_text -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    д
    л
    я
    п
    е
    ч
    а
    т
    и
    registration_organ -- Р
    е
    г
    и
    с
    т
    р
    и
    р
    у
    ю
    щ
    и
    й
    о
    р
    г
    а
    н
    contacts -- К
    о
    н
    т
    а
    к
    т
    ы
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, name=None, short_name=None, comment=None, print_text=None, registration_organ=None, contacts=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.name = name
        self.name_nsprefix_ = None
        self.short_name = short_name
        self.short_name_nsprefix_ = None
        self.comment = comment
        self.validate_MultiLiner(self.comment)
        self.comment_nsprefix_ = None
        self.print_text = print_text
        self.print_text_nsprefix_ = None
        self.registration_organ = registration_organ
        self.registration_organ_nsprefix_ = None
        self.contacts = contacts
        self.contacts_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, OtherSubject)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if OtherSubject.subclass:
            return OtherSubject.subclass(*args_, **kwargs_)
        else:
            return OtherSubject(*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_short_name(self):
        return self.short_name
    def set_short_name(self, short_name):
        self.short_name = short_name
    def get_comment(self):
        return self.comment
    def set_comment(self, comment):
        self.comment = comment
    def get_print_text(self):
        return self.print_text
    def set_print_text(self, print_text):
        self.print_text = print_text
    def get_registration_organ(self):
        return self.registration_organ
    def set_registration_organ(self, registration_organ):
        self.registration_organ = registration_organ
    def get_contacts(self):
        return self.contacts
    def set_contacts(self, contacts):
        self.contacts = contacts
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.name is not None or
            self.short_name is not None or
            self.comment is not None or
            self.print_text is not None or
            self.registration_organ is not None or
            self.contacts is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OtherSubject', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('OtherSubject')
        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_ == 'OtherSubject':
            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_='OtherSubject')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OtherSubject', 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_='OtherSubject'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='OtherSubject', 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.short_name is not None:
            namespaceprefix_ = self.short_name_nsprefix_ + ':' if (UseCapturedNS_ and self.short_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sshort_name>%s</%sshort_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.short_name), input_name='short_name')), namespaceprefix_ , eol_))
        if self.comment is not None:
            namespaceprefix_ = self.comment_nsprefix_ + ':' if (UseCapturedNS_ and self.comment_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scomment>%s</%scomment>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.comment), input_name='comment')), namespaceprefix_ , eol_))
        if self.print_text is not None:
            namespaceprefix_ = self.print_text_nsprefix_ + ':' if (UseCapturedNS_ and self.print_text_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sprint_text>%s</%sprint_text>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.print_text), input_name='print_text')), namespaceprefix_ , eol_))
        if self.registration_organ is not None:
            namespaceprefix_ = self.registration_organ_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_organ_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_organ>%s</%sregistration_organ>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.registration_organ), input_name='registration_organ')), namespaceprefix_ , eol_))
        if self.contacts is not None:
            namespaceprefix_ = self.contacts_nsprefix_ + ':' if (UseCapturedNS_ and self.contacts_nsprefix_) else ''
            self.contacts.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contacts', 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):
        pass
    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_ == 'short_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'short_name')
            value_ = self.gds_validate_string(value_, node, 'short_name')
            self.short_name = value_
            self.short_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'comment':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'comment')
            value_ = self.gds_validate_string(value_, node, 'comment')
            self.comment = value_
            self.comment_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.comment)
        elif nodeName_ == 'print_text':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'print_text')
            value_ = self.gds_validate_string(value_, node, 'print_text')
            self.print_text = value_
            self.print_text_nsprefix_ = child_.prefix
        elif nodeName_ == 'registration_organ':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'registration_organ')
            value_ = self.gds_validate_string(value_, node, 'registration_organ')
            self.registration_organ = value_
            self.registration_organ_nsprefix_ = child_.prefix
        elif nodeName_ == 'contacts':
            obj_ = Contacts.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contacts = obj_
            obj_.original_tagname_ = 'contacts'
# end class OtherSubject


class UnderlyingDocumentsRequisites(GeneratedsSuper):
    """UnderlyingDocumentsRequisites -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    underlying_document -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, underlying_document=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 underlying_document is None:
            self.underlying_document = []
        else:
            self.underlying_document = underlying_document
        self.underlying_document_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, UnderlyingDocumentsRequisites)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if UnderlyingDocumentsRequisites.subclass:
            return UnderlyingDocumentsRequisites.subclass(*args_, **kwargs_)
        else:
            return UnderlyingDocumentsRequisites(*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_underlying_document(self):
        return self.underlying_document
    def set_underlying_document(self, underlying_document):
        self.underlying_document = underlying_document
    def add_underlying_document(self, value):
        self.underlying_document.append(value)
    def insert_underlying_document_at(self, index, value):
        self.underlying_document.insert(index, value)
    def replace_underlying_document_at(self, index, value):
        self.underlying_document[index] = value
    def has__content(self):
        if (
            self.underlying_document
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentsRequisites', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnderlyingDocumentsRequisites')
        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_ == 'UnderlyingDocumentsRequisites':
            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_='UnderlyingDocumentsRequisites')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnderlyingDocumentsRequisites', 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_='UnderlyingDocumentsRequisites'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnderlyingDocumentsRequisites', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for underlying_document_ in self.underlying_document:
            namespaceprefix_ = self.underlying_document_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_document_nsprefix_) else ''
            underlying_document_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_document', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'underlying_document':
            obj_ = DocumentRequisites.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_document.append(obj_)
            obj_.original_tagname_ = 'underlying_document'
# end class UnderlyingDocumentsRequisites


class DocumentRequisites(GeneratedsSuper):
    """DocumentRequisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    д
    о
    к
    у
    м
    е
    н
    т
    о
    в
    document_code -- К
    о
    д
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    document_series -- С
    е
    р
    и
    я
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_number --
    Н
    о
    м
    е
    р
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_date -- Д
    а
    т
    а
    д
    о
    к
    у
    м
    е
    н
    т
    а
    document_issuer -- О
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    ,
    о
    р
    г
    а
    н
    и
    з
    а
    ц
    и
    я
    ,
    в
    ы
    д
    а
    в
    ш
    и
    е
    д
    о
    к
    у
    м
    е
    н
    т
    subdivision_code -- К
    о
    д
    п
    о
    д
    р
    а
    з
    д
    е
    л
    е
    н
    и
    я
    civil_number -- Н
    о
    м
    е
    р
    г
    р
    а
    ж
    д
    а
    н
    с
    к
    о
    г
    о
    д
    е
    л
    а
    special_marks -- О
    с
    о
    б
    ы
    е
    о
    т
    м
    е
    т
    к
    и
    doc_notarized -- Н
    о
    т
    а
    р
    и
    а
    л
    ь
    н
    о
    е
    у
    д
    о
    с
    т
    о
    в
    е
    р
    е
    н
    и
    е
    д
    о
    к
    у
    м
    е
    н
    т
    а
    doc_source -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    б
    а
    з
    о
    в
    о
    г
    о
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    г
    о
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    о
    н
    н
    о
    г
    о
    р
    е
    с
    у
    р
    с
    а
    ,
    п
    р
    е
    д
    о
    с
    т
    а
    в
    и
    в
    ш
    е
    г
    о
    д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    document_info -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    д
    о
    к
    у
    м
    е
    н
    т
    а
    deal_registered -- З
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    а
    с
    д
    е
    л
    к
    а
    document_start_date -- Д
    а
    т
    а
    в
    с
    т
    у
    п
    л
    е
    н
    и
    я
    в
    с
    и
    л
    у
    additional_information -- Д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, document_code=None, document_name=None, document_series=None, document_number=None, document_date=None, document_issuer=None, subdivision_code=None, civil_number=None, special_marks=None, doc_notarized=None, doc_source=None, document_info=None, deal_registered=None, document_start_date=None, additional_information=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.document_code = document_code
        self.document_code_nsprefix_ = None
        self.document_name = document_name
        self.document_name_nsprefix_ = None
        self.document_series = document_series
        self.document_series_nsprefix_ = None
        self.document_number = document_number
        self.document_number_nsprefix_ = None
        if isinstance(document_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(document_date, '%Y-%m-%d').date()
        else:
            initvalue_ = document_date
        self.document_date = initvalue_
        self.document_date_nsprefix_ = None
        self.document_issuer = document_issuer
        self.validate_MultiLiner(self.document_issuer)
        self.document_issuer_nsprefix_ = None
        self.subdivision_code = subdivision_code
        self.subdivision_code_nsprefix_ = None
        self.civil_number = civil_number
        self.civil_number_nsprefix_ = None
        self.special_marks = special_marks
        self.validate_MultiLiner(self.special_marks)
        self.special_marks_nsprefix_ = None
        self.doc_notarized = doc_notarized
        self.doc_notarized_nsprefix_ = None
        self.doc_source = doc_source
        self.doc_source_nsprefix_ = None
        self.document_info = document_info
        self.validate_MultiLiner(self.document_info)
        self.document_info_nsprefix_ = None
        self.deal_registered = deal_registered
        self.deal_registered_nsprefix_ = None
        if isinstance(document_start_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(document_start_date, '%Y-%m-%d').date()
        else:
            initvalue_ = document_start_date
        self.document_start_date = initvalue_
        self.document_start_date_nsprefix_ = None
        self.additional_information = additional_information
        self.validate_MultiLiner(self.additional_information)
        self.additional_information_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DocumentRequisites)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DocumentRequisites.subclass:
            return DocumentRequisites.subclass(*args_, **kwargs_)
        else:
            return DocumentRequisites(*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_document_code(self):
        return self.document_code
    def set_document_code(self, document_code):
        self.document_code = document_code
    def get_document_name(self):
        return self.document_name
    def set_document_name(self, document_name):
        self.document_name = document_name
    def get_document_series(self):
        return self.document_series
    def set_document_series(self, document_series):
        self.document_series = document_series
    def get_document_number(self):
        return self.document_number
    def set_document_number(self, document_number):
        self.document_number = document_number
    def get_document_date(self):
        return self.document_date
    def set_document_date(self, document_date):
        self.document_date = document_date
    def get_document_issuer(self):
        return self.document_issuer
    def set_document_issuer(self, document_issuer):
        self.document_issuer = document_issuer
    def get_subdivision_code(self):
        return self.subdivision_code
    def set_subdivision_code(self, subdivision_code):
        self.subdivision_code = subdivision_code
    def get_civil_number(self):
        return self.civil_number
    def set_civil_number(self, civil_number):
        self.civil_number = civil_number
    def get_special_marks(self):
        return self.special_marks
    def set_special_marks(self, special_marks):
        self.special_marks = special_marks
    def get_doc_notarized(self):
        return self.doc_notarized
    def set_doc_notarized(self, doc_notarized):
        self.doc_notarized = doc_notarized
    def get_doc_source(self):
        return self.doc_source
    def set_doc_source(self, doc_source):
        self.doc_source = doc_source
    def get_document_info(self):
        return self.document_info
    def set_document_info(self, document_info):
        self.document_info = document_info
    def get_deal_registered(self):
        return self.deal_registered
    def set_deal_registered(self, deal_registered):
        self.deal_registered = deal_registered
    def get_document_start_date(self):
        return self.document_start_date
    def set_document_start_date(self, document_start_date):
        self.document_start_date = document_start_date
    def get_additional_information(self):
        return self.additional_information
    def set_additional_information(self, additional_information):
        self.additional_information = additional_information
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.document_code is not None or
            self.document_name is not None or
            self.document_series is not None or
            self.document_number is not None or
            self.document_date is not None or
            self.document_issuer is not None or
            self.subdivision_code is not None or
            self.civil_number is not None or
            self.special_marks is not None or
            self.doc_notarized is not None or
            self.doc_source is not None or
            self.document_info is not None or
            self.deal_registered is not None or
            self.document_start_date is not None or
            self.additional_information is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocumentRequisites', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DocumentRequisites')
        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_ == 'DocumentRequisites':
            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_='DocumentRequisites')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DocumentRequisites', 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_='DocumentRequisites'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocumentRequisites', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.document_code is not None:
            namespaceprefix_ = self.document_code_nsprefix_ + ':' if (UseCapturedNS_ and self.document_code_nsprefix_) else ''
            self.document_code.export(outfile, level, namespaceprefix_, namespacedef_='', name_='document_code', pretty_print=pretty_print)
        if self.document_name is not None:
            namespaceprefix_ = self.document_name_nsprefix_ + ':' if (UseCapturedNS_ and self.document_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_name>%s</%sdocument_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_name), input_name='document_name')), namespaceprefix_ , eol_))
        if self.document_series is not None:
            namespaceprefix_ = self.document_series_nsprefix_ + ':' if (UseCapturedNS_ and self.document_series_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_series>%s</%sdocument_series>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_series), input_name='document_series')), namespaceprefix_ , eol_))
        if self.document_number is not None:
            namespaceprefix_ = self.document_number_nsprefix_ + ':' if (UseCapturedNS_ and self.document_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_number>%s</%sdocument_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_number), input_name='document_number')), namespaceprefix_ , eol_))
        if self.document_date is not None:
            namespaceprefix_ = self.document_date_nsprefix_ + ':' if (UseCapturedNS_ and self.document_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_date>%s</%sdocument_date>%s' % (namespaceprefix_ , self.gds_format_date(self.document_date, input_name='document_date'), namespaceprefix_ , eol_))
        if self.document_issuer is not None:
            namespaceprefix_ = self.document_issuer_nsprefix_ + ':' if (UseCapturedNS_ and self.document_issuer_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_issuer>%s</%sdocument_issuer>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_issuer), input_name='document_issuer')), namespaceprefix_ , eol_))
        if self.subdivision_code is not None:
            namespaceprefix_ = self.subdivision_code_nsprefix_ + ':' if (UseCapturedNS_ and self.subdivision_code_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssubdivision_code>%s</%ssubdivision_code>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.subdivision_code), input_name='subdivision_code')), namespaceprefix_ , eol_))
        if self.civil_number is not None:
            namespaceprefix_ = self.civil_number_nsprefix_ + ':' if (UseCapturedNS_ and self.civil_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scivil_number>%s</%scivil_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.civil_number), input_name='civil_number')), namespaceprefix_ , eol_))
        if self.special_marks is not None:
            namespaceprefix_ = self.special_marks_nsprefix_ + ':' if (UseCapturedNS_ and self.special_marks_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sspecial_marks>%s</%sspecial_marks>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.special_marks), input_name='special_marks')), namespaceprefix_ , eol_))
        if self.doc_notarized is not None:
            namespaceprefix_ = self.doc_notarized_nsprefix_ + ':' if (UseCapturedNS_ and self.doc_notarized_nsprefix_) else ''
            self.doc_notarized.export(outfile, level, namespaceprefix_, namespacedef_='', name_='doc_notarized', pretty_print=pretty_print)
        if self.doc_source is not None:
            namespaceprefix_ = self.doc_source_nsprefix_ + ':' if (UseCapturedNS_ and self.doc_source_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdoc_source>%s</%sdoc_source>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.doc_source), input_name='doc_source')), namespaceprefix_ , eol_))
        if self.document_info is not None:
            namespaceprefix_ = self.document_info_nsprefix_ + ':' if (UseCapturedNS_ and self.document_info_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_info>%s</%sdocument_info>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.document_info), input_name='document_info')), namespaceprefix_ , eol_))
        if self.deal_registered is not None:
            namespaceprefix_ = self.deal_registered_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_registered_nsprefix_) else ''
            self.deal_registered.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deal_registered', pretty_print=pretty_print)
        if self.document_start_date is not None:
            namespaceprefix_ = self.document_start_date_nsprefix_ + ':' if (UseCapturedNS_ and self.document_start_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdocument_start_date>%s</%sdocument_start_date>%s' % (namespaceprefix_ , self.gds_format_date(self.document_start_date, input_name='document_start_date'), namespaceprefix_ , eol_))
        if self.additional_information is not None:
            namespaceprefix_ = self.additional_information_nsprefix_ + ':' if (UseCapturedNS_ and self.additional_information_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sadditional_information>%s</%sadditional_information>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.additional_information), input_name='additional_information')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'document_code':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.document_code = obj_
            obj_.original_tagname_ = 'document_code'
        elif nodeName_ == 'document_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_name')
            value_ = self.gds_validate_string(value_, node, 'document_name')
            self.document_name = value_
            self.document_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_series':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_series')
            value_ = self.gds_validate_string(value_, node, 'document_series')
            self.document_series = value_
            self.document_series_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_number')
            value_ = self.gds_validate_string(value_, node, 'document_number')
            self.document_number = value_
            self.document_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.document_date = dval_
            self.document_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_issuer':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_issuer')
            value_ = self.gds_validate_string(value_, node, 'document_issuer')
            self.document_issuer = value_
            self.document_issuer_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.document_issuer)
        elif nodeName_ == 'subdivision_code':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'subdivision_code')
            value_ = self.gds_validate_string(value_, node, 'subdivision_code')
            self.subdivision_code = value_
            self.subdivision_code_nsprefix_ = child_.prefix
        elif nodeName_ == 'civil_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'civil_number')
            value_ = self.gds_validate_string(value_, node, 'civil_number')
            self.civil_number = value_
            self.civil_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'special_marks':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'special_marks')
            value_ = self.gds_validate_string(value_, node, 'special_marks')
            self.special_marks = value_
            self.special_marks_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.special_marks)
        elif nodeName_ == 'doc_notarized':
            obj_ = DocNotarized.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.doc_notarized = obj_
            obj_.original_tagname_ = 'doc_notarized'
        elif nodeName_ == 'doc_source':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'doc_source')
            value_ = self.gds_validate_string(value_, node, 'doc_source')
            self.doc_source = value_
            self.doc_source_nsprefix_ = child_.prefix
        elif nodeName_ == 'document_info':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'document_info')
            value_ = self.gds_validate_string(value_, node, 'document_info')
            self.document_info = value_
            self.document_info_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.document_info)
        elif nodeName_ == 'deal_registered':
            obj_ = DealRegistered.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deal_registered = obj_
            obj_.original_tagname_ = 'deal_registered'
        elif nodeName_ == 'document_start_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.document_start_date = dval_
            self.document_start_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'additional_information':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'additional_information')
            value_ = self.gds_validate_string(value_, node, 'additional_information')
            self.additional_information = value_
            self.additional_information_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.additional_information)
# end class DocumentRequisites


class DocNotarized(GeneratedsSuper):
    """DocNotarized -- Н
    о
    т
    а
    р
    и
    а
    л
    ь
    н
    о
    е
    у
    д
    о
    с
    т
    о
    в
    е
    р
    е
    н
    и
    е
    д
    о
    к
    у
    м
    е
    н
    т
    а
    notarize_date -- Д
    а
    т
    а
    н
    о
    т
    а
    р
    и
    а
    л
    ь
    н
    о
    г
    о
    у
    д
    о
    с
    т
    о
    в
    е
    р
    е
    н
    и
    я
    notary_name -- Ф
    а
    м
    и
    л
    и
    я
    и
    и
    н
    и
    ц
    и
    а
    л
    ы
    н
    о
    т
    а
    р
    и
    у
    с
    а
    notary_action_num -- Н
    о
    м
    е
    р
    в
    р
    е
    е
    с
    т
    р
    е
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    н
    о
    т
    а
    р
    и
    а
    л
    ь
    н
    ы
    х
    д
    е
    й
    с
    т
    в
    и
    й
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, notarize_date=None, notary_name=None, notary_action_num=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(notarize_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(notarize_date, '%Y-%m-%d').date()
        else:
            initvalue_ = notarize_date
        self.notarize_date = initvalue_
        self.notarize_date_nsprefix_ = None
        self.notary_name = notary_name
        self.notary_name_nsprefix_ = None
        self.notary_action_num = notary_action_num
        self.notary_action_num_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DocNotarized)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DocNotarized.subclass:
            return DocNotarized.subclass(*args_, **kwargs_)
        else:
            return DocNotarized(*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_notarize_date(self):
        return self.notarize_date
    def set_notarize_date(self, notarize_date):
        self.notarize_date = notarize_date
    def get_notary_name(self):
        return self.notary_name
    def set_notary_name(self, notary_name):
        self.notary_name = notary_name
    def get_notary_action_num(self):
        return self.notary_action_num
    def set_notary_action_num(self, notary_action_num):
        self.notary_action_num = notary_action_num
    def has__content(self):
        if (
            self.notarize_date is not None or
            self.notary_name is not None or
            self.notary_action_num is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocNotarized', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DocNotarized')
        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_ == 'DocNotarized':
            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_='DocNotarized')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DocNotarized', 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_='DocNotarized'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DocNotarized', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.notarize_date is not None:
            namespaceprefix_ = self.notarize_date_nsprefix_ + ':' if (UseCapturedNS_ and self.notarize_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snotarize_date>%s</%snotarize_date>%s' % (namespaceprefix_ , self.gds_format_date(self.notarize_date, input_name='notarize_date'), namespaceprefix_ , eol_))
        if self.notary_name is not None:
            namespaceprefix_ = self.notary_name_nsprefix_ + ':' if (UseCapturedNS_ and self.notary_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snotary_name>%s</%snotary_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.notary_name), input_name='notary_name')), namespaceprefix_ , eol_))
        if self.notary_action_num is not None:
            namespaceprefix_ = self.notary_action_num_nsprefix_ + ':' if (UseCapturedNS_ and self.notary_action_num_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snotary_action_num>%s</%snotary_action_num>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.notary_action_num), input_name='notary_action_num')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'notarize_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.notarize_date = dval_
            self.notarize_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'notary_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'notary_name')
            value_ = self.gds_validate_string(value_, node, 'notary_name')
            self.notary_name = value_
            self.notary_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'notary_action_num':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'notary_action_num')
            value_ = self.gds_validate_string(value_, node, 'notary_action_num')
            self.notary_action_num = value_
            self.notary_action_num_nsprefix_ = child_.prefix
# end class DocNotarized


class DealRegistered(GeneratedsSuper):
    """DealRegistered -- З
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    а
    с
    д
    е
    л
    к
    а
    deal_registered_number -- Н
    о
    м
    е
    р
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    й
    с
    д
    е
    л
    к
    и
    deal_registered_date -- Д
    а
    т
    а
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    й
    с
    д
    е
    л
    к
    и
    deal_registered_organ -- О
    р
    г
    а
    н
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, deal_registered_number=None, deal_registered_date=None, deal_registered_organ=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.deal_registered_number = deal_registered_number
        self.deal_registered_number_nsprefix_ = None
        if isinstance(deal_registered_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(deal_registered_date, '%Y-%m-%d').date()
        else:
            initvalue_ = deal_registered_date
        self.deal_registered_date = initvalue_
        self.deal_registered_date_nsprefix_ = None
        self.deal_registered_organ = deal_registered_organ
        self.deal_registered_organ_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DealRegistered)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DealRegistered.subclass:
            return DealRegistered.subclass(*args_, **kwargs_)
        else:
            return DealRegistered(*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_deal_registered_number(self):
        return self.deal_registered_number
    def set_deal_registered_number(self, deal_registered_number):
        self.deal_registered_number = deal_registered_number
    def get_deal_registered_date(self):
        return self.deal_registered_date
    def set_deal_registered_date(self, deal_registered_date):
        self.deal_registered_date = deal_registered_date
    def get_deal_registered_organ(self):
        return self.deal_registered_organ
    def set_deal_registered_organ(self, deal_registered_organ):
        self.deal_registered_organ = deal_registered_organ
    def has__content(self):
        if (
            self.deal_registered_number is not None or
            self.deal_registered_date is not None or
            self.deal_registered_organ is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRegistered', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DealRegistered')
        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_ == 'DealRegistered':
            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_='DealRegistered')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DealRegistered', 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_='DealRegistered'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRegistered', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.deal_registered_number is not None:
            namespaceprefix_ = self.deal_registered_number_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_registered_number_nsprefix_) else ''
            self.deal_registered_number.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deal_registered_number', pretty_print=pretty_print)
        if self.deal_registered_date is not None:
            namespaceprefix_ = self.deal_registered_date_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_registered_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdeal_registered_date>%s</%sdeal_registered_date>%s' % (namespaceprefix_ , self.gds_format_date(self.deal_registered_date, input_name='deal_registered_date'), namespaceprefix_ , eol_))
        if self.deal_registered_organ is not None:
            namespaceprefix_ = self.deal_registered_organ_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_registered_organ_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdeal_registered_organ>%s</%sdeal_registered_organ>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.deal_registered_organ), input_name='deal_registered_organ')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'deal_registered_number':
            obj_ = DealRecordNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deal_registered_number = obj_
            obj_.original_tagname_ = 'deal_registered_number'
        elif nodeName_ == 'deal_registered_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.deal_registered_date = dval_
            self.deal_registered_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'deal_registered_organ':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'deal_registered_organ')
            value_ = self.gds_validate_string(value_, node, 'deal_registered_organ')
            self.deal_registered_organ = value_
            self.deal_registered_organ_nsprefix_ = child_.prefix
# end class DealRegistered


class RightRecordNumber(GeneratedsSuper):
    """RightRecordNumber -- Н
    о
    м
    е
    р
    р
    е
    е
    с
    т
    р
    о
    в
    о
    й
    з
    а
    п
    и
    с
    и
    о
    в
    е
    щ
    н
    о
    м
    п
    р
    а
    в
    е
    number -- Н
    о
    м
    е
    р
    р
    е
    е
    с
    т
    р
    о
    в
    о
    й
    з
    а
    п
    и
    с
    и
    right_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    в
    е
    щ
    н
    о
    г
    о
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number=None, right_number=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.number = number
        self.validate_RecordNumber(self.number)
        self.number_nsprefix_ = None
        self.right_number = right_number
        self.right_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RightRecordNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RightRecordNumber.subclass:
            return RightRecordNumber.subclass(*args_, **kwargs_)
        else:
            return RightRecordNumber(*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_right_number(self):
        return self.right_number
    def set_right_number(self, right_number):
        self.right_number = right_number
    def validate_RecordNumber(self, value):
        result = True
        # Validate type RecordNumber, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.number is not None or
            self.right_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RightRecordNumber')
        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_ == 'RightRecordNumber':
            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_='RightRecordNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RightRecordNumber', 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_='RightRecordNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RightRecordNumber', 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.right_number is not None:
            namespaceprefix_ = self.right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.right_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sright_number>%s</%sright_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.right_number), input_name='right_number')), 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):
        pass
    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
            # validate type RecordNumber
            self.validate_RecordNumber(self.number)
        elif nodeName_ == 'right_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'right_number')
            value_ = self.gds_validate_string(value_, node, 'right_number')
            self.right_number = value_
            self.right_number_nsprefix_ = child_.prefix
# end class RightRecordNumber


class RestrictRecordNumber(GeneratedsSuper):
    """RestrictRecordNumber -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    /
    р
    е
    е
    с
    т
    р
    о
    в
    о
    й
    з
    а
    п
    и
    с
    и
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    и
    /
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    и
    number -- Н
    о
    м
    е
    р
    р
    е
    е
    с
    т
    р
    о
    в
    о
    й
    з
    а
    п
    и
    с
    и
    right_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    О
    Н
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number=None, right_number=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.number = number
        self.validate_RecordNumber(self.number)
        self.number_nsprefix_ = None
        self.right_number = right_number
        self.right_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RestrictRecordNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RestrictRecordNumber.subclass:
            return RestrictRecordNumber.subclass(*args_, **kwargs_)
        else:
            return RestrictRecordNumber(*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_right_number(self):
        return self.right_number
    def set_right_number(self, right_number):
        self.right_number = right_number
    def validate_RecordNumber(self, value):
        result = True
        # Validate type RecordNumber, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.number is not None or
            self.right_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RestrictRecordNumber')
        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_ == 'RestrictRecordNumber':
            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_='RestrictRecordNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RestrictRecordNumber', 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_='RestrictRecordNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RestrictRecordNumber', 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.right_number is not None:
            namespaceprefix_ = self.right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.right_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sright_number>%s</%sright_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.right_number), input_name='right_number')), 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):
        pass
    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
            # validate type RecordNumber
            self.validate_RecordNumber(self.number)
        elif nodeName_ == 'right_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'right_number')
            value_ = self.gds_validate_string(value_, node, 'right_number')
            self.right_number = value_
            self.right_number_nsprefix_ = child_.prefix
# end class RestrictRecordNumber


class DealRecordNumber(GeneratedsSuper):
    """DealRecordNumber -- Н
    о
    м
    е
    р
    р
    е
    е
    с
    т
    р
    о
    в
    о
    й
    з
    а
    п
    и
    с
    и
    о
    с
    д
    е
    л
    к
    е
    number -- Н
    о
    м
    е
    р
    р
    е
    е
    с
    т
    р
    о
    в
    о
    й
    з
    а
    п
    и
    с
    и
    right_number -- Н
    о
    м
    е
    р
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    с
    д
    е
    л
    к
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, number=None, right_number=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.number = number
        self.validate_RecordNumber(self.number)
        self.number_nsprefix_ = None
        self.right_number = right_number
        self.right_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DealRecordNumber)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DealRecordNumber.subclass:
            return DealRecordNumber.subclass(*args_, **kwargs_)
        else:
            return DealRecordNumber(*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_right_number(self):
        return self.right_number
    def set_right_number(self, right_number):
        self.right_number = right_number
    def validate_RecordNumber(self, value):
        result = True
        # Validate type RecordNumber, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.number is not None or
            self.right_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRecordNumber', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DealRecordNumber')
        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_ == 'DealRecordNumber':
            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_='DealRecordNumber')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DealRecordNumber', 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_='DealRecordNumber'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DealRecordNumber', 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.right_number is not None:
            namespaceprefix_ = self.right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.right_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sright_number>%s</%sright_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.right_number), input_name='right_number')), 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):
        pass
    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
            # validate type RecordNumber
            self.validate_RecordNumber(self.number)
        elif nodeName_ == 'right_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'right_number')
            value_ = self.gds_validate_string(value_, node, 'right_number')
            self.right_number = value_
            self.right_number_nsprefix_ = child_.prefix
# end class DealRecordNumber


class AddressMain(GeneratedsSuper):
    """AddressMain -- А
    д
    р
    е
    с
    (
    ф
    и
    а
    с
    )
    address_fias -- А
    д
    р
    е
    с
    (
    п
    о
    с
    п
    р
    а
    в
    о
    ч
    н
    и
    к
    у
    Ф
    И
    А
    С
    )
    note -- Н
    е
    ф
    о
    р
    м
    а
    л
    и
    з
    о
    в
    а
    н
    н
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    readable_address -- А
    д
    р
    е
    с
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    Ф
    И
    А
    С
    (
    Т
    е
    к
    с
    т
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address_fias=None, note=None, readable_address=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.address_fias = address_fias
        self.address_fias_nsprefix_ = None
        self.note = note
        self.validate_MultiLiner(self.note)
        self.note_nsprefix_ = None
        self.readable_address = readable_address
        self.validate_MultiLiner(self.readable_address)
        self.readable_address_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressMain)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressMain.subclass:
            return AddressMain.subclass(*args_, **kwargs_)
        else:
            return AddressMain(*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_address_fias(self):
        return self.address_fias
    def set_address_fias(self, address_fias):
        self.address_fias = address_fias
    def get_note(self):
        return self.note
    def set_note(self, note):
        self.note = note
    def get_readable_address(self):
        return self.readable_address
    def set_readable_address(self, readable_address):
        self.readable_address = readable_address
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.address_fias is not None or
            self.note is not None or
            self.readable_address is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressMain', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressMain')
        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_ == 'AddressMain':
            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_='AddressMain')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressMain', 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_='AddressMain'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressMain', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address_fias is not None:
            namespaceprefix_ = self.address_fias_nsprefix_ + ':' if (UseCapturedNS_ and self.address_fias_nsprefix_) else ''
            self.address_fias.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_fias', pretty_print=pretty_print)
        if self.note is not None:
            namespaceprefix_ = self.note_nsprefix_ + ':' if (UseCapturedNS_ and self.note_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snote>%s</%snote>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.note), input_name='note')), namespaceprefix_ , eol_))
        if self.readable_address is not None:
            namespaceprefix_ = self.readable_address_nsprefix_ + ':' if (UseCapturedNS_ and self.readable_address_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreadable_address>%s</%sreadable_address>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.readable_address), input_name='readable_address')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address_fias':
            obj_ = Address.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_fias = obj_
            obj_.original_tagname_ = 'address_fias'
        elif nodeName_ == 'note':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'note')
            value_ = self.gds_validate_string(value_, node, 'note')
            self.note = value_
            self.note_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.note)
        elif nodeName_ == 'readable_address':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'readable_address')
            value_ = self.gds_validate_string(value_, node, 'readable_address')
            self.readable_address = value_
            self.readable_address_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.readable_address)
# end class AddressMain


class Address(GeneratedsSuper):
    """Address -- А
    д
    р
    е
    с
    (
    о
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    )
    п
    о
    л
    н
    ы
    й
    level_settlement -- У
    р
    о
    в
    е
    н
    ь
    н
    а
    с
    е
    л
    е
    н
    н
    о
    г
    о
    п
    у
    н
    к
    т
    а
    detailed_level -- Д
    е
    т
    а
    л
    и
    з
    и
    р
    о
    в
    а
    н
    н
    ы
    й
    у
    р
    о
    в
    е
    н
    ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, level_settlement=None, detailed_level=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.level_settlement = level_settlement
        self.level_settlement_nsprefix_ = None
        self.detailed_level = detailed_level
        self.detailed_level_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Address)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Address.subclass:
            return Address.subclass(*args_, **kwargs_)
        else:
            return Address(*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_level_settlement(self):
        return self.level_settlement
    def set_level_settlement(self, level_settlement):
        self.level_settlement = level_settlement
    def get_detailed_level(self):
        return self.detailed_level
    def set_detailed_level(self, detailed_level):
        self.detailed_level = detailed_level
    def has__content(self):
        if (
            self.level_settlement is not None or
            self.detailed_level is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Address', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Address')
        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_ == 'Address':
            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_='Address')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Address', 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_='Address'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Address', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.level_settlement is not None:
            namespaceprefix_ = self.level_settlement_nsprefix_ + ':' if (UseCapturedNS_ and self.level_settlement_nsprefix_) else ''
            self.level_settlement.export(outfile, level, namespaceprefix_, namespacedef_='', name_='level_settlement', pretty_print=pretty_print)
        if self.detailed_level is not None:
            namespaceprefix_ = self.detailed_level_nsprefix_ + ':' if (UseCapturedNS_ and self.detailed_level_nsprefix_) else ''
            self.detailed_level.export(outfile, level, namespaceprefix_, namespacedef_='', name_='detailed_level', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'level_settlement':
            obj_ = AddressCity.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.level_settlement = obj_
            obj_.original_tagname_ = 'level_settlement'
        elif nodeName_ == 'detailed_level':
            obj_ = DetailedLevel.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.detailed_level = obj_
            obj_.original_tagname_ = 'detailed_level'
# end class Address


class AddressCity(GeneratedsSuper):
    """AddressCity -- А
    д
    р
    е
    с
    (
    о
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    )
    д
    о
    у
    р
    о
    в
    н
    я
    н
    а
    с
    е
    л
    ё
    н
    н
    о
    г
    о
    п
    у
    н
    к
    т
    а
    fias -- К
    о
    д
    Ф
    И
    А
    С
    okato -- О
    К
    А
    Т
    О
    kladr -- К
    о
    д
    К
    Л
    А
    Д
    Р
    oktmo -- О
    К
    Т
    М
    О
    postal_code -- П
    о
    ч
    т
    о
    в
    ы
    й
    и
    н
    д
    е
    к
    с
    region -- К
    о
    д
    р
    е
    г
    и
    о
    н
    а
    district -- Р
    а
    й
    о
    н
    city -- М
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    о
    е
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    е
    urban_district -- Г
    о
    р
    о
    д
    с
    к
    о
    й
    р
    а
    й
    о
    н
    soviet_village -- С
    е
    л
    ь
    с
    о
    в
    е
    т
    locality -- Н
    а
    с
    е
    л
    ё
    н
    н
    ы
    й
    п
    у
    н
    к
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, fias=None, okato=None, kladr=None, oktmo=None, postal_code=None, region=None, district=None, city=None, urban_district=None, soviet_village=None, locality=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.fias = fias
        self.fias_nsprefix_ = None
        self.okato = okato
        self.okato_nsprefix_ = None
        self.kladr = kladr
        self.kladr_nsprefix_ = None
        self.oktmo = oktmo
        self.oktmo_nsprefix_ = None
        self.postal_code = postal_code
        self.validate_postal_codeType(self.postal_code)
        self.postal_code_nsprefix_ = None
        self.region = region
        self.region_nsprefix_ = None
        self.district = district
        self.district_nsprefix_ = None
        self.city = city
        self.city_nsprefix_ = None
        self.urban_district = urban_district
        self.urban_district_nsprefix_ = None
        self.soviet_village = soviet_village
        self.soviet_village_nsprefix_ = None
        self.locality = locality
        self.locality_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressCity)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressCity.subclass:
            return AddressCity.subclass(*args_, **kwargs_)
        else:
            return AddressCity(*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_fias(self):
        return self.fias
    def set_fias(self, fias):
        self.fias = fias
    def get_okato(self):
        return self.okato
    def set_okato(self, okato):
        self.okato = okato
    def get_kladr(self):
        return self.kladr
    def set_kladr(self, kladr):
        self.kladr = kladr
    def get_oktmo(self):
        return self.oktmo
    def set_oktmo(self, oktmo):
        self.oktmo = oktmo
    def get_postal_code(self):
        return self.postal_code
    def set_postal_code(self, postal_code):
        self.postal_code = postal_code
    def get_region(self):
        return self.region
    def set_region(self, region):
        self.region = region
    def get_district(self):
        return self.district
    def set_district(self, district):
        self.district = district
    def get_city(self):
        return self.city
    def set_city(self, city):
        self.city = city
    def get_urban_district(self):
        return self.urban_district
    def set_urban_district(self, urban_district):
        self.urban_district = urban_district
    def get_soviet_village(self):
        return self.soviet_village
    def set_soviet_village(self, soviet_village):
        self.soviet_village = soviet_village
    def get_locality(self):
        return self.locality
    def set_locality(self, locality):
        self.locality = locality
    def validate_postal_codeType(self, value):
        result = True
        # Validate type postal_codeType, 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
            if len(value) != 6:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd length restriction on postal_codeType' % {"value": encode_str_2_3(value), "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.fias is not None or
            self.okato is not None or
            self.kladr is not None or
            self.oktmo is not None or
            self.postal_code is not None or
            self.region is not None or
            self.district is not None or
            self.city is not None or
            self.urban_district is not None or
            self.soviet_village is not None or
            self.locality is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressCity', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressCity')
        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_ == 'AddressCity':
            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_='AddressCity')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressCity', 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_='AddressCity'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressCity', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.fias is not None:
            namespaceprefix_ = self.fias_nsprefix_ + ':' if (UseCapturedNS_ and self.fias_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfias>%s</%sfias>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.fias), input_name='fias')), namespaceprefix_ , eol_))
        if self.okato is not None:
            namespaceprefix_ = self.okato_nsprefix_ + ':' if (UseCapturedNS_ and self.okato_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sokato>%s</%sokato>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.okato), input_name='okato')), namespaceprefix_ , eol_))
        if self.kladr is not None:
            namespaceprefix_ = self.kladr_nsprefix_ + ':' if (UseCapturedNS_ and self.kladr_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%skladr>%s</%skladr>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.kladr), input_name='kladr')), namespaceprefix_ , eol_))
        if self.oktmo is not None:
            namespaceprefix_ = self.oktmo_nsprefix_ + ':' if (UseCapturedNS_ and self.oktmo_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%soktmo>%s</%soktmo>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.oktmo), input_name='oktmo')), namespaceprefix_ , eol_))
        if self.postal_code is not None:
            namespaceprefix_ = self.postal_code_nsprefix_ + ':' if (UseCapturedNS_ and self.postal_code_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spostal_code>%s</%spostal_code>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.postal_code), input_name='postal_code')), namespaceprefix_ , eol_))
        if self.region is not None:
            namespaceprefix_ = self.region_nsprefix_ + ':' if (UseCapturedNS_ and self.region_nsprefix_) else ''
            self.region.export(outfile, level, namespaceprefix_, namespacedef_='', name_='region', pretty_print=pretty_print)
        if self.district is not None:
            namespaceprefix_ = self.district_nsprefix_ + ':' if (UseCapturedNS_ and self.district_nsprefix_) else ''
            self.district.export(outfile, level, namespaceprefix_, namespacedef_='', name_='district', pretty_print=pretty_print)
        if self.city is not None:
            namespaceprefix_ = self.city_nsprefix_ + ':' if (UseCapturedNS_ and self.city_nsprefix_) else ''
            self.city.export(outfile, level, namespaceprefix_, namespacedef_='', name_='city', pretty_print=pretty_print)
        if self.urban_district is not None:
            namespaceprefix_ = self.urban_district_nsprefix_ + ':' if (UseCapturedNS_ and self.urban_district_nsprefix_) else ''
            self.urban_district.export(outfile, level, namespaceprefix_, namespacedef_='', name_='urban_district', pretty_print=pretty_print)
        if self.soviet_village is not None:
            namespaceprefix_ = self.soviet_village_nsprefix_ + ':' if (UseCapturedNS_ and self.soviet_village_nsprefix_) else ''
            self.soviet_village.export(outfile, level, namespaceprefix_, namespacedef_='', name_='soviet_village', pretty_print=pretty_print)
        if self.locality is not None:
            namespaceprefix_ = self.locality_nsprefix_ + ':' if (UseCapturedNS_ and self.locality_nsprefix_) else ''
            self.locality.export(outfile, level, namespaceprefix_, namespacedef_='', name_='locality', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'fias':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'fias')
            value_ = self.gds_validate_string(value_, node, 'fias')
            self.fias = value_
            self.fias_nsprefix_ = child_.prefix
        elif nodeName_ == 'okato':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'okato')
            value_ = self.gds_validate_string(value_, node, 'okato')
            self.okato = value_
            self.okato_nsprefix_ = child_.prefix
        elif nodeName_ == 'kladr':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'kladr')
            value_ = self.gds_validate_string(value_, node, 'kladr')
            self.kladr = value_
            self.kladr_nsprefix_ = child_.prefix
        elif nodeName_ == 'oktmo':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'oktmo')
            value_ = self.gds_validate_string(value_, node, 'oktmo')
            self.oktmo = value_
            self.oktmo_nsprefix_ = child_.prefix
        elif nodeName_ == 'postal_code':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'postal_code')
            value_ = self.gds_validate_string(value_, node, 'postal_code')
            self.postal_code = value_
            self.postal_code_nsprefix_ = child_.prefix
            # validate type postal_codeType
            self.validate_postal_codeType(self.postal_code)
        elif nodeName_ == 'region':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.region = obj_
            obj_.original_tagname_ = 'region'
        elif nodeName_ == 'district':
            obj_ = District.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.district = obj_
            obj_.original_tagname_ = 'district'
        elif nodeName_ == 'city':
            obj_ = City.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.city = obj_
            obj_.original_tagname_ = 'city'
        elif nodeName_ == 'urban_district':
            obj_ = UrbanDistrict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.urban_district = obj_
            obj_.original_tagname_ = 'urban_district'
        elif nodeName_ == 'soviet_village':
            obj_ = SovietVillage.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.soviet_village = obj_
            obj_.original_tagname_ = 'soviet_village'
        elif nodeName_ == 'locality':
            obj_ = Locality.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.locality = obj_
            obj_.original_tagname_ = 'locality'
# end class AddressCity


class DetailedLevel(GeneratedsSuper):
    """DetailedLevel -- Д
    е
    т
    а
    л
    и
    з
    и
    р
    о
    в
    а
    н
    н
    ы
    й
    у
    р
    о
    в
    е
    н
    ь
    street -- У
    л
    и
    ц
    а
    level1 -- Д
    о
    м
    level2 -- К
    о
    р
    п
    у
    с
    level3 -- С
    т
    р
    о
    е
    н
    и
    е
    apartment -- К
    в
    а
    р
    т
    и
    р
    а
    other -- И
    н
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, street=None, level1=None, level2=None, level3=None, apartment=None, other=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.street = street
        self.street_nsprefix_ = None
        self.level1 = level1
        self.level1_nsprefix_ = None
        self.level2 = level2
        self.level2_nsprefix_ = None
        self.level3 = level3
        self.level3_nsprefix_ = None
        self.apartment = apartment
        self.apartment_nsprefix_ = None
        self.other = other
        self.other_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DetailedLevel)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DetailedLevel.subclass:
            return DetailedLevel.subclass(*args_, **kwargs_)
        else:
            return DetailedLevel(*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_level1(self):
        return self.level1
    def set_level1(self, level1):
        self.level1 = level1
    def get_level2(self):
        return self.level2
    def set_level2(self, level2):
        self.level2 = level2
    def get_level3(self):
        return self.level3
    def set_level3(self, level3):
        self.level3 = level3
    def get_apartment(self):
        return self.apartment
    def set_apartment(self, apartment):
        self.apartment = apartment
    def get_other(self):
        return self.other
    def set_other(self, other):
        self.other = other
    def has__content(self):
        if (
            self.street is not None or
            self.level1 is not None or
            self.level2 is not None or
            self.level3 is not None or
            self.apartment is not None or
            self.other is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DetailedLevel', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DetailedLevel')
        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_ == 'DetailedLevel':
            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_='DetailedLevel')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DetailedLevel', 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_='DetailedLevel'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DetailedLevel', 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 ''
            self.street.export(outfile, level, namespaceprefix_, namespacedef_='', name_='street', pretty_print=pretty_print)
        if self.level1 is not None:
            namespaceprefix_ = self.level1_nsprefix_ + ':' if (UseCapturedNS_ and self.level1_nsprefix_) else ''
            self.level1.export(outfile, level, namespaceprefix_, namespacedef_='', name_='level1', pretty_print=pretty_print)
        if self.level2 is not None:
            namespaceprefix_ = self.level2_nsprefix_ + ':' if (UseCapturedNS_ and self.level2_nsprefix_) else ''
            self.level2.export(outfile, level, namespaceprefix_, namespacedef_='', name_='level2', pretty_print=pretty_print)
        if self.level3 is not None:
            namespaceprefix_ = self.level3_nsprefix_ + ':' if (UseCapturedNS_ and self.level3_nsprefix_) else ''
            self.level3.export(outfile, level, namespaceprefix_, namespacedef_='', name_='level3', pretty_print=pretty_print)
        if self.apartment is not None:
            namespaceprefix_ = self.apartment_nsprefix_ + ':' if (UseCapturedNS_ and self.apartment_nsprefix_) else ''
            self.apartment.export(outfile, level, namespaceprefix_, namespacedef_='', name_='apartment', pretty_print=pretty_print)
        if self.other is not None:
            namespaceprefix_ = self.other_nsprefix_ + ':' if (UseCapturedNS_ and self.other_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sother>%s</%sother>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.other), input_name='other')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'street':
            obj_ = Street.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.street = obj_
            obj_.original_tagname_ = 'street'
        elif nodeName_ == 'level1':
            obj_ = Level1.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.level1 = obj_
            obj_.original_tagname_ = 'level1'
        elif nodeName_ == 'level2':
            obj_ = Level2.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.level2 = obj_
            obj_.original_tagname_ = 'level2'
        elif nodeName_ == 'level3':
            obj_ = Level3.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.level3 = obj_
            obj_.original_tagname_ = 'level3'
        elif nodeName_ == 'apartment':
            obj_ = Apartment.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.apartment = obj_
            obj_.original_tagname_ = 'apartment'
        elif nodeName_ == 'other':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'other')
            value_ = self.gds_validate_string(value_, node, 'other')
            self.other = value_
            self.other_nsprefix_ = child_.prefix
# end class DetailedLevel


class Apartment(GeneratedsSuper):
    """Apartment -- К
    в
    а
    р
    т
    и
    р
    а
    type_apartment -- Т
    и
    п
    name_apartment -- З
    н
    а
    ч
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_apartment=None, name_apartment=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.type_apartment = type_apartment
        self.type_apartment_nsprefix_ = None
        self.name_apartment = name_apartment
        self.name_apartment_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Apartment)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Apartment.subclass:
            return Apartment.subclass(*args_, **kwargs_)
        else:
            return Apartment(*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_type_apartment(self):
        return self.type_apartment
    def set_type_apartment(self, type_apartment):
        self.type_apartment = type_apartment
    def get_name_apartment(self):
        return self.name_apartment
    def set_name_apartment(self, name_apartment):
        self.name_apartment = name_apartment
    def has__content(self):
        if (
            self.type_apartment is not None or
            self.name_apartment is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Apartment', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Apartment')
        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_ == 'Apartment':
            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_='Apartment')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Apartment', 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_='Apartment'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Apartment', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_apartment is not None:
            namespaceprefix_ = self.type_apartment_nsprefix_ + ':' if (UseCapturedNS_ and self.type_apartment_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_apartment>%s</%stype_apartment>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_apartment), input_name='type_apartment')), namespaceprefix_ , eol_))
        if self.name_apartment is not None:
            namespaceprefix_ = self.name_apartment_nsprefix_ + ':' if (UseCapturedNS_ and self.name_apartment_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_apartment>%s</%sname_apartment>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_apartment), input_name='name_apartment')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_apartment':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_apartment')
            value_ = self.gds_validate_string(value_, node, 'type_apartment')
            self.type_apartment = value_
            self.type_apartment_nsprefix_ = child_.prefix
        elif nodeName_ == 'name_apartment':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_apartment')
            value_ = self.gds_validate_string(value_, node, 'name_apartment')
            self.name_apartment = value_
            self.name_apartment_nsprefix_ = child_.prefix
# end class Apartment


class City(GeneratedsSuper):
    """City -- М
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    о
    е
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    е
    type_city -- Т
    и
    п
    name_city -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_city=None, name_city=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.type_city = type_city
        self.type_city_nsprefix_ = None
        self.name_city = name_city
        self.name_city_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, City)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if City.subclass:
            return City.subclass(*args_, **kwargs_)
        else:
            return City(*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_type_city(self):
        return self.type_city
    def set_type_city(self, type_city):
        self.type_city = type_city
    def get_name_city(self):
        return self.name_city
    def set_name_city(self, name_city):
        self.name_city = name_city
    def has__content(self):
        if (
            self.type_city is not None or
            self.name_city is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='City', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('City')
        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_ == 'City':
            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_='City')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='City', 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_='City'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='City', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_city is not None:
            namespaceprefix_ = self.type_city_nsprefix_ + ':' if (UseCapturedNS_ and self.type_city_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_city>%s</%stype_city>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_city), input_name='type_city')), namespaceprefix_ , eol_))
        if self.name_city is not None:
            namespaceprefix_ = self.name_city_nsprefix_ + ':' if (UseCapturedNS_ and self.name_city_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_city>%s</%sname_city>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_city), input_name='name_city')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_city':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_city')
            value_ = self.gds_validate_string(value_, node, 'type_city')
            self.type_city = value_
            self.type_city_nsprefix_ = child_.prefix
        elif nodeName_ == 'name_city':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_city')
            value_ = self.gds_validate_string(value_, node, 'name_city')
            self.name_city = value_
            self.name_city_nsprefix_ = child_.prefix
# end class City


class District(GeneratedsSuper):
    """District -- Р
    а
    й
    о
    н
    type_district -- Т
    и
    п
    name_district -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_district=None, name_district=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.type_district = type_district
        self.type_district_nsprefix_ = None
        self.name_district = name_district
        self.name_district_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, District)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if District.subclass:
            return District.subclass(*args_, **kwargs_)
        else:
            return District(*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_type_district(self):
        return self.type_district
    def set_type_district(self, type_district):
        self.type_district = type_district
    def get_name_district(self):
        return self.name_district
    def set_name_district(self, name_district):
        self.name_district = name_district
    def has__content(self):
        if (
            self.type_district is not None or
            self.name_district is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='District', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('District')
        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_ == 'District':
            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_='District')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='District', 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_='District'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='District', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_district is not None:
            namespaceprefix_ = self.type_district_nsprefix_ + ':' if (UseCapturedNS_ and self.type_district_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_district>%s</%stype_district>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_district), input_name='type_district')), namespaceprefix_ , eol_))
        if self.name_district is not None:
            namespaceprefix_ = self.name_district_nsprefix_ + ':' if (UseCapturedNS_ and self.name_district_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_district>%s</%sname_district>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_district), input_name='name_district')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_district':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_district')
            value_ = self.gds_validate_string(value_, node, 'type_district')
            self.type_district = value_
            self.type_district_nsprefix_ = child_.prefix
        elif nodeName_ == 'name_district':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_district')
            value_ = self.gds_validate_string(value_, node, 'name_district')
            self.name_district = value_
            self.name_district_nsprefix_ = child_.prefix
# end class District


class Level1(GeneratedsSuper):
    """Level1 -- Д
    о
    м
    type_level1 -- Т
    и
    п
    name_level1 -- З
    н
    а
    ч
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_level1=None, name_level1=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.type_level1 = type_level1
        self.type_level1_nsprefix_ = None
        self.name_level1 = name_level1
        self.name_level1_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Level1)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Level1.subclass:
            return Level1.subclass(*args_, **kwargs_)
        else:
            return Level1(*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_type_level1(self):
        return self.type_level1
    def set_type_level1(self, type_level1):
        self.type_level1 = type_level1
    def get_name_level1(self):
        return self.name_level1
    def set_name_level1(self, name_level1):
        self.name_level1 = name_level1
    def has__content(self):
        if (
            self.type_level1 is not None or
            self.name_level1 is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Level1', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Level1')
        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_ == 'Level1':
            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_='Level1')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Level1', 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_='Level1'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Level1', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_level1 is not None:
            namespaceprefix_ = self.type_level1_nsprefix_ + ':' if (UseCapturedNS_ and self.type_level1_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_level1>%s</%stype_level1>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_level1), input_name='type_level1')), namespaceprefix_ , eol_))
        if self.name_level1 is not None:
            namespaceprefix_ = self.name_level1_nsprefix_ + ':' if (UseCapturedNS_ and self.name_level1_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_level1>%s</%sname_level1>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_level1), input_name='name_level1')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_level1':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_level1')
            value_ = self.gds_validate_string(value_, node, 'type_level1')
            self.type_level1 = value_
            self.type_level1_nsprefix_ = child_.prefix
        elif nodeName_ == 'name_level1':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_level1')
            value_ = self.gds_validate_string(value_, node, 'name_level1')
            self.name_level1 = value_
            self.name_level1_nsprefix_ = child_.prefix
# end class Level1


class Level2(GeneratedsSuper):
    """Level2 -- К
    о
    р
    п
    у
    с
    type_level2 -- Т
    и
    п
    name_level2 -- З
    н
    а
    ч
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_level2=None, name_level2=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.type_level2 = type_level2
        self.type_level2_nsprefix_ = None
        self.name_level2 = name_level2
        self.name_level2_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Level2)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Level2.subclass:
            return Level2.subclass(*args_, **kwargs_)
        else:
            return Level2(*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_type_level2(self):
        return self.type_level2
    def set_type_level2(self, type_level2):
        self.type_level2 = type_level2
    def get_name_level2(self):
        return self.name_level2
    def set_name_level2(self, name_level2):
        self.name_level2 = name_level2
    def has__content(self):
        if (
            self.type_level2 is not None or
            self.name_level2 is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Level2', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Level2')
        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_ == 'Level2':
            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_='Level2')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Level2', 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_='Level2'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Level2', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_level2 is not None:
            namespaceprefix_ = self.type_level2_nsprefix_ + ':' if (UseCapturedNS_ and self.type_level2_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_level2>%s</%stype_level2>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_level2), input_name='type_level2')), namespaceprefix_ , eol_))
        if self.name_level2 is not None:
            namespaceprefix_ = self.name_level2_nsprefix_ + ':' if (UseCapturedNS_ and self.name_level2_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_level2>%s</%sname_level2>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_level2), input_name='name_level2')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_level2':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_level2')
            value_ = self.gds_validate_string(value_, node, 'type_level2')
            self.type_level2 = value_
            self.type_level2_nsprefix_ = child_.prefix
        elif nodeName_ == 'name_level2':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_level2')
            value_ = self.gds_validate_string(value_, node, 'name_level2')
            self.name_level2 = value_
            self.name_level2_nsprefix_ = child_.prefix
# end class Level2


class Level3(GeneratedsSuper):
    """Level3 -- С
    т
    р
    о
    е
    н
    и
    е
    type_level3 -- Т
    и
    п
    name_level3 -- З
    н
    а
    ч
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_level3=None, name_level3=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.type_level3 = type_level3
        self.type_level3_nsprefix_ = None
        self.name_level3 = name_level3
        self.name_level3_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Level3)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Level3.subclass:
            return Level3.subclass(*args_, **kwargs_)
        else:
            return Level3(*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_type_level3(self):
        return self.type_level3
    def set_type_level3(self, type_level3):
        self.type_level3 = type_level3
    def get_name_level3(self):
        return self.name_level3
    def set_name_level3(self, name_level3):
        self.name_level3 = name_level3
    def has__content(self):
        if (
            self.type_level3 is not None or
            self.name_level3 is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Level3', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Level3')
        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_ == 'Level3':
            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_='Level3')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Level3', 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_='Level3'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Level3', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_level3 is not None:
            namespaceprefix_ = self.type_level3_nsprefix_ + ':' if (UseCapturedNS_ and self.type_level3_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_level3>%s</%stype_level3>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_level3), input_name='type_level3')), namespaceprefix_ , eol_))
        if self.name_level3 is not None:
            namespaceprefix_ = self.name_level3_nsprefix_ + ':' if (UseCapturedNS_ and self.name_level3_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_level3>%s</%sname_level3>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_level3), input_name='name_level3')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_level3':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_level3')
            value_ = self.gds_validate_string(value_, node, 'type_level3')
            self.type_level3 = value_
            self.type_level3_nsprefix_ = child_.prefix
        elif nodeName_ == 'name_level3':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_level3')
            value_ = self.gds_validate_string(value_, node, 'name_level3')
            self.name_level3 = value_
            self.name_level3_nsprefix_ = child_.prefix
# end class Level3


class Locality(GeneratedsSuper):
    """Locality -- Н
    а
    с
    е
    л
    ё
    н
    н
    ы
    й
    п
    у
    н
    к
    т
    type_locality -- Т
    и
    п
    name_locality -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_locality=None, name_locality=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.type_locality = type_locality
        self.type_locality_nsprefix_ = None
        self.name_locality = name_locality
        self.name_locality_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Locality)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Locality.subclass:
            return Locality.subclass(*args_, **kwargs_)
        else:
            return Locality(*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_type_locality(self):
        return self.type_locality
    def set_type_locality(self, type_locality):
        self.type_locality = type_locality
    def get_name_locality(self):
        return self.name_locality
    def set_name_locality(self, name_locality):
        self.name_locality = name_locality
    def has__content(self):
        if (
            self.type_locality is not None or
            self.name_locality is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Locality', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Locality')
        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_ == 'Locality':
            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_='Locality')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Locality', 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_='Locality'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Locality', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_locality is not None:
            namespaceprefix_ = self.type_locality_nsprefix_ + ':' if (UseCapturedNS_ and self.type_locality_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_locality>%s</%stype_locality>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_locality), input_name='type_locality')), namespaceprefix_ , eol_))
        if self.name_locality is not None:
            namespaceprefix_ = self.name_locality_nsprefix_ + ':' if (UseCapturedNS_ and self.name_locality_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_locality>%s</%sname_locality>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_locality), input_name='name_locality')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_locality':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_locality')
            value_ = self.gds_validate_string(value_, node, 'type_locality')
            self.type_locality = value_
            self.type_locality_nsprefix_ = child_.prefix
        elif nodeName_ == 'name_locality':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_locality')
            value_ = self.gds_validate_string(value_, node, 'name_locality')
            self.name_locality = value_
            self.name_locality_nsprefix_ = child_.prefix
# end class Locality


class Note(GeneratedsSuper):
    """Note -- Н
    е
    ф
    о
    р
    м
    а
    л
    и
    з
    о
    в
    а
    н
    н
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    code -- К
    о
    д
    д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    ы
    х
    с
    в
    е
    д
    е
    н
    и
    й
    text -- Д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    ы
    е
    с
    в
    е
    д
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, code=None, text=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.code = code
        self.code_nsprefix_ = None
        self.text = text
        self.text_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Note)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Note.subclass:
            return Note.subclass(*args_, **kwargs_)
        else:
            return Note(*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_text(self):
        return self.text
    def set_text(self, text):
        self.text = text
    def has__content(self):
        if (
            self.code is not None or
            self.text is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Note', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Note')
        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_ == 'Note':
            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_='Note')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Note', 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_='Note'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Note', 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.text is not None:
            namespaceprefix_ = self.text_nsprefix_ + ':' if (UseCapturedNS_ and self.text_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stext>%s</%stext>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.text), input_name='text')), 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):
        pass
    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_ == 'text':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'text')
            value_ = self.gds_validate_string(value_, node, 'text')
            self.text = value_
            self.text_nsprefix_ = child_.prefix
# end class Note


class SovietVillage(GeneratedsSuper):
    """SovietVillage -- С
    е
    л
    ь
    с
    о
    в
    е
    т
    type_soviet_village -- Т
    и
    п
    name__soviet_village -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_soviet_village=None, name__soviet_village=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.type_soviet_village = type_soviet_village
        self.type_soviet_village_nsprefix_ = None
        self.name__soviet_village = name__soviet_village
        self.name__soviet_village_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SovietVillage)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SovietVillage.subclass:
            return SovietVillage.subclass(*args_, **kwargs_)
        else:
            return SovietVillage(*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_type_soviet_village(self):
        return self.type_soviet_village
    def set_type_soviet_village(self, type_soviet_village):
        self.type_soviet_village = type_soviet_village
    def get_name__soviet_village(self):
        return self.name__soviet_village
    def set_name__soviet_village(self, name__soviet_village):
        self.name__soviet_village = name__soviet_village
    def has__content(self):
        if (
            self.type_soviet_village is not None or
            self.name__soviet_village is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SovietVillage', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SovietVillage')
        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_ == 'SovietVillage':
            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_='SovietVillage')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SovietVillage', 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_='SovietVillage'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SovietVillage', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_soviet_village is not None:
            namespaceprefix_ = self.type_soviet_village_nsprefix_ + ':' if (UseCapturedNS_ and self.type_soviet_village_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_soviet_village>%s</%stype_soviet_village>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_soviet_village), input_name='type_soviet_village')), namespaceprefix_ , eol_))
        if self.name__soviet_village is not None:
            namespaceprefix_ = self.name__soviet_village_nsprefix_ + ':' if (UseCapturedNS_ and self.name__soviet_village_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname__soviet_village>%s</%sname__soviet_village>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name__soviet_village), input_name='name__soviet_village')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_soviet_village':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_soviet_village')
            value_ = self.gds_validate_string(value_, node, 'type_soviet_village')
            self.type_soviet_village = value_
            self.type_soviet_village_nsprefix_ = child_.prefix
        elif nodeName_ == 'name__soviet_village':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name__soviet_village')
            value_ = self.gds_validate_string(value_, node, 'name__soviet_village')
            self.name__soviet_village = value_
            self.name__soviet_village_nsprefix_ = child_.prefix
# end class SovietVillage


class Street(GeneratedsSuper):
    """Street -- У
    л
    и
    ц
    а
    type_street -- Т
    и
    п
    name_street -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_street=None, name_street=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.type_street = type_street
        self.type_street_nsprefix_ = None
        self.name_street = name_street
        self.name_street_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Street)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Street.subclass:
            return Street.subclass(*args_, **kwargs_)
        else:
            return Street(*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_type_street(self):
        return self.type_street
    def set_type_street(self, type_street):
        self.type_street = type_street
    def get_name_street(self):
        return self.name_street
    def set_name_street(self, name_street):
        self.name_street = name_street
    def has__content(self):
        if (
            self.type_street is not None or
            self.name_street is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Street', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Street')
        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_ == 'Street':
            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_='Street')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Street', 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_='Street'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Street', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_street is not None:
            namespaceprefix_ = self.type_street_nsprefix_ + ':' if (UseCapturedNS_ and self.type_street_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_street>%s</%stype_street>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_street), input_name='type_street')), namespaceprefix_ , eol_))
        if self.name_street is not None:
            namespaceprefix_ = self.name_street_nsprefix_ + ':' if (UseCapturedNS_ and self.name_street_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_street>%s</%sname_street>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_street), input_name='name_street')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_street':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_street')
            value_ = self.gds_validate_string(value_, node, 'type_street')
            self.type_street = value_
            self.type_street_nsprefix_ = child_.prefix
        elif nodeName_ == 'name_street':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_street')
            value_ = self.gds_validate_string(value_, node, 'name_street')
            self.name_street = value_
            self.name_street_nsprefix_ = child_.prefix
# end class Street


class UrbanDistrict(GeneratedsSuper):
    """UrbanDistrict -- Г
    о
    р
    о
    д
    с
    к
    о
    й
    р
    а
    й
    о
    н
    type_urban_district -- Т
    и
    п
    name_urban_district -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_urban_district=None, name_urban_district=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.type_urban_district = type_urban_district
        self.type_urban_district_nsprefix_ = None
        self.name_urban_district = name_urban_district
        self.name_urban_district_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, UrbanDistrict)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if UrbanDistrict.subclass:
            return UrbanDistrict.subclass(*args_, **kwargs_)
        else:
            return UrbanDistrict(*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_type_urban_district(self):
        return self.type_urban_district
    def set_type_urban_district(self, type_urban_district):
        self.type_urban_district = type_urban_district
    def get_name_urban_district(self):
        return self.name_urban_district
    def set_name_urban_district(self, name_urban_district):
        self.name_urban_district = name_urban_district
    def has__content(self):
        if (
            self.type_urban_district is not None or
            self.name_urban_district is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UrbanDistrict', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UrbanDistrict')
        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_ == 'UrbanDistrict':
            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_='UrbanDistrict')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UrbanDistrict', 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_='UrbanDistrict'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UrbanDistrict', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_urban_district is not None:
            namespaceprefix_ = self.type_urban_district_nsprefix_ + ':' if (UseCapturedNS_ and self.type_urban_district_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stype_urban_district>%s</%stype_urban_district>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_urban_district), input_name='type_urban_district')), namespaceprefix_ , eol_))
        if self.name_urban_district is not None:
            namespaceprefix_ = self.name_urban_district_nsprefix_ + ':' if (UseCapturedNS_ and self.name_urban_district_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname_urban_district>%s</%sname_urban_district>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name_urban_district), input_name='name_urban_district')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type_urban_district':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'type_urban_district')
            value_ = self.gds_validate_string(value_, node, 'type_urban_district')
            self.type_urban_district = value_
            self.type_urban_district_nsprefix_ = child_.prefix
        elif nodeName_ == 'name_urban_district':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name_urban_district')
            value_ = self.gds_validate_string(value_, node, 'name_urban_district')
            self.name_urban_district = value_
            self.name_urban_district_nsprefix_ = child_.prefix
# end class UrbanDistrict


class AddressLocationLand(GeneratedsSuper):
    """AddressLocationLand -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    address_type -- Т
    и
    п
    а
    д
    р
    е
    с
    а
    address -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    rel_position -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    о
    т
    н
    о
    с
    и
    т
    е
    л
    ь
    н
    о
    о
    р
    и
    е
    н
    т
    и
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address_type=None, address=None, rel_position=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.address_type = address_type
        self.address_type_nsprefix_ = None
        self.address = address
        self.address_nsprefix_ = None
        self.rel_position = rel_position
        self.rel_position_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressLocationLand)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressLocationLand.subclass:
            return AddressLocationLand.subclass(*args_, **kwargs_)
        else:
            return AddressLocationLand(*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_address_type(self):
        return self.address_type
    def set_address_type(self, address_type):
        self.address_type = address_type
    def get_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def get_rel_position(self):
        return self.rel_position
    def set_rel_position(self, rel_position):
        self.rel_position = rel_position
    def has__content(self):
        if (
            self.address_type is not None or
            self.address is not None or
            self.rel_position is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationLand', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressLocationLand')
        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_ == 'AddressLocationLand':
            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_='AddressLocationLand')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressLocationLand', 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_='AddressLocationLand'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationLand', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address_type is not None:
            namespaceprefix_ = self.address_type_nsprefix_ + ':' if (UseCapturedNS_ and self.address_type_nsprefix_) else ''
            self.address_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_type', pretty_print=pretty_print)
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', pretty_print=pretty_print)
        if self.rel_position is not None:
            namespaceprefix_ = self.rel_position_nsprefix_ + ':' if (UseCapturedNS_ and self.rel_position_nsprefix_) else ''
            self.rel_position.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rel_position', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_type = obj_
            obj_.original_tagname_ = 'address_type'
        elif nodeName_ == 'address':
            obj_ = AddressMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
        elif nodeName_ == 'rel_position':
            obj_ = LocationByARefPoint.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.rel_position = obj_
            obj_.original_tagname_ = 'rel_position'
# end class AddressLocationLand


class AddressLocationBuild(GeneratedsSuper):
    """AddressLocationBuild -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    з
    д
    а
    н
    и
    я
    address_type -- Т
    и
    п
    а
    д
    р
    е
    с
    а
    address -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    location -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address_type=None, address=None, location=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.address_type = address_type
        self.address_type_nsprefix_ = None
        self.address = address
        self.address_nsprefix_ = None
        self.location = location
        self.location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressLocationBuild)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressLocationBuild.subclass:
            return AddressLocationBuild.subclass(*args_, **kwargs_)
        else:
            return AddressLocationBuild(*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_address_type(self):
        return self.address_type
    def set_address_type(self, address_type):
        self.address_type = address_type
    def get_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def get_location(self):
        return self.location
    def set_location(self, location):
        self.location = location
    def has__content(self):
        if (
            self.address_type is not None or
            self.address is not None or
            self.location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationBuild', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressLocationBuild')
        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_ == 'AddressLocationBuild':
            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_='AddressLocationBuild')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressLocationBuild', 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_='AddressLocationBuild'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationBuild', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address_type is not None:
            namespaceprefix_ = self.address_type_nsprefix_ + ':' if (UseCapturedNS_ and self.address_type_nsprefix_) else ''
            self.address_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_type', pretty_print=pretty_print)
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', pretty_print=pretty_print)
        if self.location is not None:
            namespaceprefix_ = self.location_nsprefix_ + ':' if (UseCapturedNS_ and self.location_nsprefix_) else ''
            self.location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_type = obj_
            obj_.original_tagname_ = 'address_type'
        elif nodeName_ == 'address':
            obj_ = AddressMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
        elif nodeName_ == 'location':
            obj_ = LocationOks.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.location = obj_
            obj_.original_tagname_ = 'location'
# end class AddressLocationBuild


class AddressLocationConstruction(GeneratedsSuper):
    """AddressLocationConstruction -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    -
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    ,
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    ,
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    address_type -- Т
    и
    п
    а
    д
    р
    е
    с
    а
    address -- А
    д
    р
    е
    с
    locations -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    я
    с
    у
    б
    ъ
    е
    к
    т
    о
    в
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    ,
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    й
    ,
    н
    а
    с
    е
    л
    е
    н
    н
    ы
    х
    п
    у
    н
    к
    т
    о
    в
    (
    п
    р
    и
    н
    а
    л
    и
    ч
    и
    и
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address_type=None, address=None, locations=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.address_type = address_type
        self.address_type_nsprefix_ = None
        self.address = address
        self.address_nsprefix_ = None
        self.locations = locations
        self.locations_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressLocationConstruction)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressLocationConstruction.subclass:
            return AddressLocationConstruction.subclass(*args_, **kwargs_)
        else:
            return AddressLocationConstruction(*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_address_type(self):
        return self.address_type
    def set_address_type(self, address_type):
        self.address_type = address_type
    def get_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def get_locations(self):
        return self.locations
    def set_locations(self, locations):
        self.locations = locations
    def has__content(self):
        if (
            self.address_type is not None or
            self.address is not None or
            self.locations is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationConstruction', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressLocationConstruction')
        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_ == 'AddressLocationConstruction':
            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_='AddressLocationConstruction')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressLocationConstruction', 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_='AddressLocationConstruction'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationConstruction', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address_type is not None:
            namespaceprefix_ = self.address_type_nsprefix_ + ':' if (UseCapturedNS_ and self.address_type_nsprefix_) else ''
            self.address_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_type', pretty_print=pretty_print)
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', pretty_print=pretty_print)
        if self.locations is not None:
            namespaceprefix_ = self.locations_nsprefix_ + ':' if (UseCapturedNS_ and self.locations_nsprefix_) else ''
            self.locations.export(outfile, level, namespaceprefix_, namespacedef_='', name_='locations', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_type = obj_
            obj_.original_tagname_ = 'address_type'
        elif nodeName_ == 'address':
            obj_ = AddressMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
        elif nodeName_ == 'locations':
            obj_ = LocationsCity.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.locations = obj_
            obj_.original_tagname_ = 'locations'
# end class AddressLocationConstruction


class AddressLocationPropertyComplex(GeneratedsSuper):
    """AddressLocationPropertyComplex -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    п
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    ,
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    (
    а
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    н
    а
    х
    о
    ж
    е
    н
    и
    е
    )
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    )
    address -- А
    д
    р
    е
    с
    location -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address=None, location=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.address = address
        self.address_nsprefix_ = None
        self.location = location
        self.location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressLocationPropertyComplex)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressLocationPropertyComplex.subclass:
            return AddressLocationPropertyComplex.subclass(*args_, **kwargs_)
        else:
            return AddressLocationPropertyComplex(*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_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def get_location(self):
        return self.location
    def set_location(self, location):
        self.location = location
    def has__content(self):
        if (
            self.address is not None or
            self.location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationPropertyComplex', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressLocationPropertyComplex')
        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_ == 'AddressLocationPropertyComplex':
            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_='AddressLocationPropertyComplex')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressLocationPropertyComplex', 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_='AddressLocationPropertyComplex'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationPropertyComplex', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', pretty_print=pretty_print)
        if self.location is not None:
            namespaceprefix_ = self.location_nsprefix_ + ':' if (UseCapturedNS_ and self.location_nsprefix_) else ''
            self.location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address':
            obj_ = AddressMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
        elif nodeName_ == 'location':
            obj_ = LocationOks.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.location = obj_
            obj_.original_tagname_ = 'location'
# end class AddressLocationPropertyComplex


class AddressOksLocation(GeneratedsSuper):
    """AddressOksLocation -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    ,
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    address_type -- Т
    и
    п
    а
    д
    р
    е
    с
    а
    address -- А
    д
    р
    е
    с
    location -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address_type=None, address=None, location=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.address_type = address_type
        self.address_type_nsprefix_ = None
        self.address = address
        self.address_nsprefix_ = None
        self.location = location
        self.location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressOksLocation)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressOksLocation.subclass:
            return AddressOksLocation.subclass(*args_, **kwargs_)
        else:
            return AddressOksLocation(*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_address_type(self):
        return self.address_type
    def set_address_type(self, address_type):
        self.address_type = address_type
    def get_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def get_location(self):
        return self.location
    def set_location(self, location):
        self.location = location
    def has__content(self):
        if (
            self.address_type is not None or
            self.address is not None or
            self.location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressOksLocation', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressOksLocation')
        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_ == 'AddressOksLocation':
            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_='AddressOksLocation')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressOksLocation', 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_='AddressOksLocation'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressOksLocation', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address_type is not None:
            namespaceprefix_ = self.address_type_nsprefix_ + ':' if (UseCapturedNS_ and self.address_type_nsprefix_) else ''
            self.address_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_type', pretty_print=pretty_print)
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', pretty_print=pretty_print)
        if self.location is not None:
            namespaceprefix_ = self.location_nsprefix_ + ':' if (UseCapturedNS_ and self.location_nsprefix_) else ''
            self.location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_type = obj_
            obj_.original_tagname_ = 'address_type'
        elif nodeName_ == 'address':
            obj_ = AddressMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
        elif nodeName_ == 'location':
            obj_ = LocationOks.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.location = obj_
            obj_.original_tagname_ = 'location'
# end class AddressOksLocation


class AddressLocationRoom(GeneratedsSuper):
    """AddressLocationRoom -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    address -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    room_number -- Н
    о
    м
    е
    р
    к
    о
    м
    н
    а
    т
    ы
    в
    к
    в
    а
    р
    т
    и
    р
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address=None, room_number=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.address = address
        self.address_nsprefix_ = None
        self.room_number = room_number
        self.room_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressLocationRoom)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressLocationRoom.subclass:
            return AddressLocationRoom.subclass(*args_, **kwargs_)
        else:
            return AddressLocationRoom(*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_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def get_room_number(self):
        return self.room_number
    def set_room_number(self, room_number):
        self.room_number = room_number
    def has__content(self):
        if (
            self.address is not None or
            self.room_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationRoom', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressLocationRoom')
        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_ == 'AddressLocationRoom':
            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_='AddressLocationRoom')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressLocationRoom', 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_='AddressLocationRoom'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationRoom', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', pretty_print=pretty_print)
        if self.room_number is not None:
            namespaceprefix_ = self.room_number_nsprefix_ + ':' if (UseCapturedNS_ and self.room_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sroom_number>%s</%sroom_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.room_number), input_name='room_number')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address':
            obj_ = AddressOksLocation.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
        elif nodeName_ == 'room_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'room_number')
            value_ = self.gds_validate_string(value_, node, 'room_number')
            self.room_number = value_
            self.room_number_nsprefix_ = child_.prefix
# end class AddressLocationRoom


class AddressLocationCarParkingSpace(GeneratedsSuper):
    """AddressLocationCarParkingSpace -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    address -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address=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.address = address
        self.address_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressLocationCarParkingSpace)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressLocationCarParkingSpace.subclass:
            return AddressLocationCarParkingSpace.subclass(*args_, **kwargs_)
        else:
            return AddressLocationCarParkingSpace(*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_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def has__content(self):
        if (
            self.address is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationCarParkingSpace', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressLocationCarParkingSpace')
        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_ == 'AddressLocationCarParkingSpace':
            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_='AddressLocationCarParkingSpace')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressLocationCarParkingSpace', 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_='AddressLocationCarParkingSpace'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationCarParkingSpace', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address':
            obj_ = AddressOksLocation.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
# end class AddressLocationCarParkingSpace


class LocationOks(GeneratedsSuper):
    """LocationOks -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    О
    К
    С
    okato -- OKATO
    oktmo -- OKTMO
    region -- К
    о
    д
    р
    е
    г
    и
    о
    н
    а
    position_description -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, okato=None, oktmo=None, region=None, position_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.okato = okato
        self.okato_nsprefix_ = None
        self.oktmo = oktmo
        self.oktmo_nsprefix_ = None
        self.region = region
        self.region_nsprefix_ = None
        self.position_description = position_description
        self.validate_MultiLiner(self.position_description)
        self.position_description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LocationOks)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LocationOks.subclass:
            return LocationOks.subclass(*args_, **kwargs_)
        else:
            return LocationOks(*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_okato(self):
        return self.okato
    def set_okato(self, okato):
        self.okato = okato
    def get_oktmo(self):
        return self.oktmo
    def set_oktmo(self, oktmo):
        self.oktmo = oktmo
    def get_region(self):
        return self.region
    def set_region(self, region):
        self.region = region
    def get_position_description(self):
        return self.position_description
    def set_position_description(self, position_description):
        self.position_description = position_description
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.okato is not None or
            self.oktmo is not None or
            self.region is not None or
            self.position_description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationOks', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LocationOks')
        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_ == 'LocationOks':
            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_='LocationOks')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LocationOks', 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_='LocationOks'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationOks', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.okato is not None:
            namespaceprefix_ = self.okato_nsprefix_ + ':' if (UseCapturedNS_ and self.okato_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sokato>%s</%sokato>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.okato), input_name='okato')), namespaceprefix_ , eol_))
        if self.oktmo is not None:
            namespaceprefix_ = self.oktmo_nsprefix_ + ':' if (UseCapturedNS_ and self.oktmo_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%soktmo>%s</%soktmo>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.oktmo), input_name='oktmo')), namespaceprefix_ , eol_))
        if self.region is not None:
            namespaceprefix_ = self.region_nsprefix_ + ':' if (UseCapturedNS_ and self.region_nsprefix_) else ''
            self.region.export(outfile, level, namespaceprefix_, namespacedef_='', name_='region', pretty_print=pretty_print)
        if self.position_description is not None:
            namespaceprefix_ = self.position_description_nsprefix_ + ':' if (UseCapturedNS_ and self.position_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sposition_description>%s</%sposition_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.position_description), input_name='position_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'okato':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'okato')
            value_ = self.gds_validate_string(value_, node, 'okato')
            self.okato = value_
            self.okato_nsprefix_ = child_.prefix
        elif nodeName_ == 'oktmo':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'oktmo')
            value_ = self.gds_validate_string(value_, node, 'oktmo')
            self.oktmo = value_
            self.oktmo_nsprefix_ = child_.prefix
        elif nodeName_ == 'region':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.region = obj_
            obj_.original_tagname_ = 'region'
        elif nodeName_ == 'position_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'position_description')
            value_ = self.gds_validate_string(value_, node, 'position_description')
            self.position_description = value_
            self.position_description_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.position_description)
# end class LocationOks


class LocationsCity(GeneratedsSuper):
    """LocationsCity -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    я
    с
    у
    б
    ъ
    е
    к
    т
    о
    в
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    ,
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    ы
    х
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    й
    ,
    н
    а
    с
    е
    л
    е
    н
    н
    ы
    х
    п
    у
    н
    к
    т
    о
    в
    (
    п
    р
    и
    н
    а
    л
    и
    ч
    и
    и
    )
    location -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    с
    у
    б
    ъ
    е
    к
    т
    а
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    ,
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    о
    г
    о
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    я
    ,
    н
    а
    с
    е
    л
    е
    н
    н
    о
    г
    о
    п
    у
    н
    к
    т
    а
    (
    п
    р
    и
    н
    а
    л
    и
    ч
    и
    и
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, location=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 location is None:
            self.location = []
        else:
            self.location = location
        self.location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LocationsCity)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LocationsCity.subclass:
            return LocationsCity.subclass(*args_, **kwargs_)
        else:
            return LocationsCity(*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_location(self):
        return self.location
    def set_location(self, location):
        self.location = location
    def add_location(self, value):
        self.location.append(value)
    def insert_location_at(self, index, value):
        self.location.insert(index, value)
    def replace_location_at(self, index, value):
        self.location[index] = value
    def has__content(self):
        if (
            self.location
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationsCity', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LocationsCity')
        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_ == 'LocationsCity':
            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_='LocationsCity')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LocationsCity', 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_='LocationsCity'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationsCity', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for location_ in self.location:
            namespaceprefix_ = self.location_nsprefix_ + ':' if (UseCapturedNS_ and self.location_nsprefix_) else ''
            location_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'location':
            obj_ = LocationCity.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.location.append(obj_)
            obj_.original_tagname_ = 'location'
# end class LocationsCity


class LocationCity(GeneratedsSuper):
    """LocationCity -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    (
    д
    о
    у
    р
    о
    в
    н
    я
    н
    а
    с
    е
    л
    е
    н
    н
    о
    г
    о
    п
    у
    н
    к
    т
    а
    )
    level_settlement -- У
    р
    о
    в
    е
    н
    ь
    н
    а
    с
    е
    л
    е
    н
    н
    о
    г
    о
    п
    у
    н
    к
    т
    а
    position_description -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, level_settlement=None, position_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.level_settlement = level_settlement
        self.level_settlement_nsprefix_ = None
        self.position_description = position_description
        self.validate_MultiLiner(self.position_description)
        self.position_description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LocationCity)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LocationCity.subclass:
            return LocationCity.subclass(*args_, **kwargs_)
        else:
            return LocationCity(*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_level_settlement(self):
        return self.level_settlement
    def set_level_settlement(self, level_settlement):
        self.level_settlement = level_settlement
    def get_position_description(self):
        return self.position_description
    def set_position_description(self, position_description):
        self.position_description = position_description
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.level_settlement is not None or
            self.position_description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationCity', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LocationCity')
        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_ == 'LocationCity':
            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_='LocationCity')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LocationCity', 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_='LocationCity'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationCity', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.level_settlement is not None:
            namespaceprefix_ = self.level_settlement_nsprefix_ + ':' if (UseCapturedNS_ and self.level_settlement_nsprefix_) else ''
            self.level_settlement.export(outfile, level, namespaceprefix_, namespacedef_='', name_='level_settlement', pretty_print=pretty_print)
        if self.position_description is not None:
            namespaceprefix_ = self.position_description_nsprefix_ + ':' if (UseCapturedNS_ and self.position_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sposition_description>%s</%sposition_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.position_description), input_name='position_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'level_settlement':
            obj_ = AddressCity.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.level_settlement = obj_
            obj_.original_tagname_ = 'level_settlement'
        elif nodeName_ == 'position_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'position_description')
            value_ = self.gds_validate_string(value_, node, 'position_description')
            self.position_description = value_
            self.position_description_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.position_description)
# end class LocationCity


class AddressLocationRefPoint(GeneratedsSuper):
    """AddressLocationRefPoint -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    address -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    rel_position -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    о
    т
    н
    о
    с
    и
    т
    е
    л
    ь
    н
    о
    о
    р
    и
    е
    н
    т
    и
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address=None, rel_position=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.address = address
        self.address_nsprefix_ = None
        self.rel_position = rel_position
        self.rel_position_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressLocationRefPoint)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressLocationRefPoint.subclass:
            return AddressLocationRefPoint.subclass(*args_, **kwargs_)
        else:
            return AddressLocationRefPoint(*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_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def get_rel_position(self):
        return self.rel_position
    def set_rel_position(self, rel_position):
        self.rel_position = rel_position
    def has__content(self):
        if (
            self.address is not None or
            self.rel_position is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationRefPoint', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressLocationRefPoint')
        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_ == 'AddressLocationRefPoint':
            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_='AddressLocationRefPoint')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressLocationRefPoint', 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_='AddressLocationRefPoint'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationRefPoint', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', pretty_print=pretty_print)
        if self.rel_position is not None:
            namespaceprefix_ = self.rel_position_nsprefix_ + ':' if (UseCapturedNS_ and self.rel_position_nsprefix_) else ''
            self.rel_position.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rel_position', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address':
            obj_ = addressType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
        elif nodeName_ == 'rel_position':
            obj_ = LocationByARefPoint.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.rel_position = obj_
            obj_.original_tagname_ = 'rel_position'
# end class AddressLocationRefPoint


class LocationByARefPoint(GeneratedsSuper):
    """LocationByARefPoint -- М
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    о
    т
    н
    о
    с
    и
    т
    е
    л
    ь
    н
    о
    о
    р
    и
    е
    н
    т
    и
    р
    а
    in_boundaries_mark -- О
    р
    и
    е
    н
    т
    и
    р
    р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    в
    г
    р
    а
    н
    и
    ц
    а
    х
    у
    ч
    а
    с
    т
    к
    а
    ref_point_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    р
    и
    е
    н
    т
    и
    р
    а
    location_description -- Р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    о
    т
    н
    о
    с
    и
    т
    е
    л
    ь
    н
    о
    о
    р
    и
    е
    н
    т
    и
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, in_boundaries_mark=None, ref_point_name=None, location_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.in_boundaries_mark = in_boundaries_mark
        self.in_boundaries_mark_nsprefix_ = None
        self.ref_point_name = ref_point_name
        self.validate_MultiLiner(self.ref_point_name)
        self.ref_point_name_nsprefix_ = None
        self.location_description = location_description
        self.validate_MultiLiner(self.location_description)
        self.location_description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, LocationByARefPoint)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if LocationByARefPoint.subclass:
            return LocationByARefPoint.subclass(*args_, **kwargs_)
        else:
            return LocationByARefPoint(*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_in_boundaries_mark(self):
        return self.in_boundaries_mark
    def set_in_boundaries_mark(self, in_boundaries_mark):
        self.in_boundaries_mark = in_boundaries_mark
    def get_ref_point_name(self):
        return self.ref_point_name
    def set_ref_point_name(self, ref_point_name):
        self.ref_point_name = ref_point_name
    def get_location_description(self):
        return self.location_description
    def set_location_description(self, location_description):
        self.location_description = location_description
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.in_boundaries_mark is not None or
            self.ref_point_name is not None or
            self.location_description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationByARefPoint', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LocationByARefPoint')
        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_ == 'LocationByARefPoint':
            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_='LocationByARefPoint')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LocationByARefPoint', 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_='LocationByARefPoint'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LocationByARefPoint', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.in_boundaries_mark is not None:
            namespaceprefix_ = self.in_boundaries_mark_nsprefix_ + ':' if (UseCapturedNS_ and self.in_boundaries_mark_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sin_boundaries_mark>%s</%sin_boundaries_mark>%s' % (namespaceprefix_ , self.gds_format_boolean(self.in_boundaries_mark, input_name='in_boundaries_mark'), namespaceprefix_ , eol_))
        if self.ref_point_name is not None:
            namespaceprefix_ = self.ref_point_name_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_point_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sref_point_name>%s</%sref_point_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.ref_point_name), input_name='ref_point_name')), namespaceprefix_ , eol_))
        if self.location_description is not None:
            namespaceprefix_ = self.location_description_nsprefix_ + ':' if (UseCapturedNS_ and self.location_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%slocation_description>%s</%slocation_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.location_description), input_name='location_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'in_boundaries_mark':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'in_boundaries_mark')
            ival_ = self.gds_validate_boolean(ival_, node, 'in_boundaries_mark')
            self.in_boundaries_mark = ival_
            self.in_boundaries_mark_nsprefix_ = child_.prefix
        elif nodeName_ == 'ref_point_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'ref_point_name')
            value_ = self.gds_validate_string(value_, node, 'ref_point_name')
            self.ref_point_name = value_
            self.ref_point_name_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.ref_point_name)
        elif nodeName_ == 'location_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'location_description')
            value_ = self.gds_validate_string(value_, node, 'location_description')
            self.location_description = value_
            self.location_description_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.location_description)
# end class LocationByARefPoint


class AddressLocationText(GeneratedsSuper):
    """AddressLocationText -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    address -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address=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.address = address
        self.address_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressLocationText)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressLocationText.subclass:
            return AddressLocationText.subclass(*args_, **kwargs_)
        else:
            return AddressLocationText(*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_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def has__content(self):
        if (
            self.address is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationText', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressLocationText')
        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_ == 'AddressLocationText':
            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_='AddressLocationText')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressLocationText', 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_='AddressLocationText'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressLocationText', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address':
            obj_ = AddressText.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
# end class AddressLocationText


class AddressText(GeneratedsSuper):
    """AddressText -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    note -- Н
    е
    ф
    о
    р
    м
    а
    л
    и
    з
    о
    в
    а
    н
    н
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    readable_address -- А
    д
    р
    е
    с
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    Ф
    И
    А
    С
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, note=None, readable_address=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.note = note
        self.note_nsprefix_ = None
        self.readable_address = readable_address
        self.validate_MultiLiner(self.readable_address)
        self.readable_address_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressText)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressText.subclass:
            return AddressText.subclass(*args_, **kwargs_)
        else:
            return AddressText(*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_note(self):
        return self.note
    def set_note(self, note):
        self.note = note
    def get_readable_address(self):
        return self.readable_address
    def set_readable_address(self, readable_address):
        self.readable_address = readable_address
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.note is not None or
            self.readable_address is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressText', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressText')
        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_ == 'AddressText':
            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_='AddressText')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressText', 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_='AddressText'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressText', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.note is not None:
            namespaceprefix_ = self.note_nsprefix_ + ':' if (UseCapturedNS_ and self.note_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snote>%s</%snote>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.note), input_name='note')), namespaceprefix_ , eol_))
        if self.readable_address is not None:
            namespaceprefix_ = self.readable_address_nsprefix_ + ':' if (UseCapturedNS_ and self.readable_address_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreadable_address>%s</%sreadable_address>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.readable_address), input_name='readable_address')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'note':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'note')
            value_ = self.gds_validate_string(value_, node, 'note')
            self.note = value_
            self.note_nsprefix_ = child_.prefix
        elif nodeName_ == 'readable_address':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'readable_address')
            value_ = self.gds_validate_string(value_, node, 'readable_address')
            self.readable_address = value_
            self.readable_address_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.readable_address)
# end class AddressText


class AddressRoom(GeneratedsSuper):
    """AddressRoom -- А
    д
    р
    е
    с
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    address -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    room_number -- Н
    о
    м
    е
    р
    к
    о
    м
    н
    а
    т
    ы
    в
    к
    в
    а
    р
    т
    и
    р
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, address=None, room_number=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.address = address
        self.address_nsprefix_ = None
        self.room_number = room_number
        self.room_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AddressRoom)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AddressRoom.subclass:
            return AddressRoom.subclass(*args_, **kwargs_)
        else:
            return AddressRoom(*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_address(self):
        return self.address
    def set_address(self, address):
        self.address = address
    def get_room_number(self):
        return self.room_number
    def set_room_number(self, room_number):
        self.room_number = room_number
    def has__content(self):
        if (
            self.address is not None or
            self.room_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressRoom', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AddressRoom')
        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_ == 'AddressRoom':
            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_='AddressRoom')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AddressRoom', 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_='AddressRoom'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AddressRoom', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.address is not None:
            namespaceprefix_ = self.address_nsprefix_ + ':' if (UseCapturedNS_ and self.address_nsprefix_) else ''
            self.address.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address', pretty_print=pretty_print)
        if self.room_number is not None:
            namespaceprefix_ = self.room_number_nsprefix_ + ':' if (UseCapturedNS_ and self.room_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sroom_number>%s</%sroom_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.room_number), input_name='room_number')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'address':
            obj_ = AddressLocationText.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address = obj_
            obj_.original_tagname_ = 'address'
        elif nodeName_ == 'room_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'room_number')
            value_ = self.gds_validate_string(value_, node, 'room_number')
            self.room_number = value_
            self.room_number_nsprefix_ = child_.prefix
# end class AddressRoom


class Subject(GeneratedsSuper):
    """Subject -- П
    р
    е
    д
    м
    е
    т
    с
    д
    е
    л
    к
    и
    subject_description -- О
    п
    и
    с
    а
    н
    и
    е
    п
    р
    е
    д
    м
    е
    т
    а
    с
    д
    е
    л
    к
    и
    share_subject_description -- О
    п
    и
    с
    а
    н
    и
    е
    п
    р
    е
    д
    м
    е
    т
    а
    д
    о
    л
    е
    в
    о
    г
    о
    у
    ч
    а
    с
    т
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, subject_description=None, share_subject_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.subject_description = subject_description
        self.validate_MultiLiner(self.subject_description)
        self.subject_description_nsprefix_ = None
        self.share_subject_description = share_subject_description
        self.share_subject_description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Subject)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Subject.subclass:
            return Subject.subclass(*args_, **kwargs_)
        else:
            return Subject(*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_subject_description(self):
        return self.subject_description
    def set_subject_description(self, subject_description):
        self.subject_description = subject_description
    def get_share_subject_description(self):
        return self.share_subject_description
    def set_share_subject_description(self, share_subject_description):
        self.share_subject_description = share_subject_description
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.subject_description is not None or
            self.share_subject_description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Subject', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Subject')
        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_ == 'Subject':
            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_='Subject')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Subject', 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_='Subject'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Subject', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.subject_description is not None:
            namespaceprefix_ = self.subject_description_nsprefix_ + ':' if (UseCapturedNS_ and self.subject_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssubject_description>%s</%ssubject_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.subject_description), input_name='subject_description')), namespaceprefix_ , eol_))
        if self.share_subject_description is not None:
            namespaceprefix_ = self.share_subject_description_nsprefix_ + ':' if (UseCapturedNS_ and self.share_subject_description_nsprefix_) else ''
            self.share_subject_description.export(outfile, level, namespaceprefix_, namespacedef_='', name_='share_subject_description', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'subject_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'subject_description')
            value_ = self.gds_validate_string(value_, node, 'subject_description')
            self.subject_description = value_
            self.subject_description_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.subject_description)
        elif nodeName_ == 'share_subject_description':
            obj_ = ShareSubjectDescription.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.share_subject_description = obj_
            obj_.original_tagname_ = 'share_subject_description'
# end class Subject


class ShareSubjectDescription(GeneratedsSuper):
    """ShareSubjectDescription -- О
    п
    и
    с
    а
    н
    и
    е
    п
    р
    е
    д
    м
    е
    т
    а
    д
    о
    л
    е
    в
    о
    г
    о
    у
    ч
    а
    с
    т
    и
    я
    house_descriptions -- О
    п
    и
    с
    а
    н
    и
    е
    д
    о
    м
    о
    в
    enforcement -- О
    б
    е
    с
    п
    е
    ч
    е
    н
    и
    е
    и
    с
    п
    о
    л
    н
    е
    н
    и
    я
    text_enforcement -- О
    п
    и
    с
    а
    н
    и
    е
    о
    б
    е
    с
    п
    е
    ч
    е
    н
    и
    я
    и
    с
    п
    о
    л
    н
    е
    н
    и
    я
    (
    т
    е
    к
    с
    т
    )
    deposit_info -- С
    в
    е
    д
    е
    н
    и
    я
    о
    н
    а
    х
    о
    ж
    д
    е
    н
    и
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    в
    з
    а
    л
    о
    г
    е
    у
    у
    ч
    а
    с
    т
    н
    и
    к
    а
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    ods_description -- Т
    е
    к
    с
    т
    о
    в
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    bank -- Б
    а
    н
    к
    ,
    в
    к
    о
    т
    о
    р
    о
    м
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    д
    о
    г
    о
    в
    о
    р
    о
    м
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    д
    о
    л
    ж
    е
    н
    б
    ы
    т
    ь
    о
    т
    к
    р
    ы
    т
    с
    п
    е
    ц
    и
    а
    л
    ь
    н
    ы
    й
    с
    ч
    е
    т
    э
    с
    к
    р
    о
    у
    д
    л
    я
    у
    с
    л
    о
    в
    н
    о
    г
    о
    д
    е
    п
    о
    н
    и
    р
    о
    в
    а
    н
    и
    я
    д
    е
    н
    е
    ж
    н
    ы
    х
    с
    р
    е
    д
    с
    т
    в
    в
    с
    ч
    е
    т
    у
    п
    л
    а
    т
    ы
    ц
    е
    н
    ы
    т
    а
    к
    о
    г
    о
    д
    о
    г
    о
    в
    о
    р
    а
    another_guarantors -- П
    о
    р
    у
    ч
    и
    т
    е
    л
    и
    /
    с
    о
    п
    о
    р
    у
    ч
    и
    т
    е
    л
    и
    ,
    з
    а
    к
    л
    ю
    ч
    и
    в
    ш
    и
    е
    д
    о
    г
    о
    в
    о
    р
    п
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    п
    о
    о
    б
    я
    з
    а
    т
    е
    л
    ь
    с
    т
    в
    а
    м
    з
    а
    с
    т
    р
    о
    й
    щ
    и
    к
    а
    ,
    р
    а
    з
    м
    е
    р
    у
    с
    т
    а
    в
    н
    о
    г
    о
    к
    а
    п
    и
    т
    а
    л
    а
    к
    о
    т
    о
    р
    о
    г
    о
    н
    е
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    у
    е
    т
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    м
    214-
    Ф
    З
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, house_descriptions=None, enforcement=None, text_enforcement=None, deposit_info=None, ods_description=None, bank=None, another_guarantors=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.house_descriptions = house_descriptions
        self.house_descriptions_nsprefix_ = None
        self.enforcement = enforcement
        self.enforcement_nsprefix_ = None
        self.text_enforcement = text_enforcement
        self.validate_MultiLiner(self.text_enforcement)
        self.text_enforcement_nsprefix_ = None
        self.deposit_info = deposit_info
        self.validate_MultiLiner(self.deposit_info)
        self.deposit_info_nsprefix_ = None
        self.ods_description = ods_description
        self.validate_MultiLiner(self.ods_description)
        self.ods_description_nsprefix_ = None
        self.bank = bank
        self.bank_nsprefix_ = None
        self.another_guarantors = another_guarantors
        self.another_guarantors_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ShareSubjectDescription)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ShareSubjectDescription.subclass:
            return ShareSubjectDescription.subclass(*args_, **kwargs_)
        else:
            return ShareSubjectDescription(*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_house_descriptions(self):
        return self.house_descriptions
    def set_house_descriptions(self, house_descriptions):
        self.house_descriptions = house_descriptions
    def get_enforcement(self):
        return self.enforcement
    def set_enforcement(self, enforcement):
        self.enforcement = enforcement
    def get_text_enforcement(self):
        return self.text_enforcement
    def set_text_enforcement(self, text_enforcement):
        self.text_enforcement = text_enforcement
    def get_deposit_info(self):
        return self.deposit_info
    def set_deposit_info(self, deposit_info):
        self.deposit_info = deposit_info
    def get_ods_description(self):
        return self.ods_description
    def set_ods_description(self, ods_description):
        self.ods_description = ods_description
    def get_bank(self):
        return self.bank
    def set_bank(self, bank):
        self.bank = bank
    def get_another_guarantors(self):
        return self.another_guarantors
    def set_another_guarantors(self, another_guarantors):
        self.another_guarantors = another_guarantors
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.house_descriptions is not None or
            self.enforcement is not None or
            self.text_enforcement is not None or
            self.deposit_info is not None or
            self.ods_description is not None or
            self.bank is not None or
            self.another_guarantors is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ShareSubjectDescription', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ShareSubjectDescription')
        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_ == 'ShareSubjectDescription':
            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_='ShareSubjectDescription')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ShareSubjectDescription', 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_='ShareSubjectDescription'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ShareSubjectDescription', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.house_descriptions is not None:
            namespaceprefix_ = self.house_descriptions_nsprefix_ + ':' if (UseCapturedNS_ and self.house_descriptions_nsprefix_) else ''
            self.house_descriptions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='house_descriptions', pretty_print=pretty_print)
        if self.enforcement is not None:
            namespaceprefix_ = self.enforcement_nsprefix_ + ':' if (UseCapturedNS_ and self.enforcement_nsprefix_) else ''
            self.enforcement.export(outfile, level, namespaceprefix_, namespacedef_='', name_='enforcement', pretty_print=pretty_print)
        if self.text_enforcement is not None:
            namespaceprefix_ = self.text_enforcement_nsprefix_ + ':' if (UseCapturedNS_ and self.text_enforcement_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stext_enforcement>%s</%stext_enforcement>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.text_enforcement), input_name='text_enforcement')), namespaceprefix_ , eol_))
        if self.deposit_info is not None:
            namespaceprefix_ = self.deposit_info_nsprefix_ + ':' if (UseCapturedNS_ and self.deposit_info_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdeposit_info>%s</%sdeposit_info>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.deposit_info), input_name='deposit_info')), namespaceprefix_ , eol_))
        if self.ods_description is not None:
            namespaceprefix_ = self.ods_description_nsprefix_ + ':' if (UseCapturedNS_ and self.ods_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sods_description>%s</%sods_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.ods_description), input_name='ods_description')), namespaceprefix_ , eol_))
        if self.bank is not None:
            namespaceprefix_ = self.bank_nsprefix_ + ':' if (UseCapturedNS_ and self.bank_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbank>%s</%sbank>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.bank), input_name='bank')), namespaceprefix_ , eol_))
        if self.another_guarantors is not None:
            namespaceprefix_ = self.another_guarantors_nsprefix_ + ':' if (UseCapturedNS_ and self.another_guarantors_nsprefix_) else ''
            self.another_guarantors.export(outfile, level, namespaceprefix_, namespacedef_='', name_='another_guarantors', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'house_descriptions':
            obj_ = HouseDescriptions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.house_descriptions = obj_
            obj_.original_tagname_ = 'house_descriptions'
        elif nodeName_ == 'enforcement':
            obj_ = Enforcement.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.enforcement = obj_
            obj_.original_tagname_ = 'enforcement'
        elif nodeName_ == 'text_enforcement':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'text_enforcement')
            value_ = self.gds_validate_string(value_, node, 'text_enforcement')
            self.text_enforcement = value_
            self.text_enforcement_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.text_enforcement)
        elif nodeName_ == 'deposit_info':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'deposit_info')
            value_ = self.gds_validate_string(value_, node, 'deposit_info')
            self.deposit_info = value_
            self.deposit_info_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.deposit_info)
        elif nodeName_ == 'ods_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'ods_description')
            value_ = self.gds_validate_string(value_, node, 'ods_description')
            self.ods_description = value_
            self.ods_description_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.ods_description)
        elif nodeName_ == 'bank':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'bank')
            value_ = self.gds_validate_string(value_, node, 'bank')
            self.bank = value_
            self.bank_nsprefix_ = child_.prefix
        elif nodeName_ == 'another_guarantors':
            obj_ = AnotherGuarantors.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.another_guarantors = obj_
            obj_.original_tagname_ = 'another_guarantors'
# end class ShareSubjectDescription


class HouseDescriptions(GeneratedsSuper):
    """HouseDescriptions -- О
    п
    и
    с
    а
    н
    и
    е
    д
    о
    м
    о
    в
    house_description -- О
    п
    и
    с
    а
    н
    и
    е
    д
    о
    м
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, house_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
        if house_description is None:
            self.house_description = []
        else:
            self.house_description = house_description
        self.house_description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, HouseDescriptions)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if HouseDescriptions.subclass:
            return HouseDescriptions.subclass(*args_, **kwargs_)
        else:
            return HouseDescriptions(*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_house_description(self):
        return self.house_description
    def set_house_description(self, house_description):
        self.house_description = house_description
    def add_house_description(self, value):
        self.house_description.append(value)
    def insert_house_description_at(self, index, value):
        self.house_description.insert(index, value)
    def replace_house_description_at(self, index, value):
        self.house_description[index] = value
    def has__content(self):
        if (
            self.house_description
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='HouseDescriptions', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('HouseDescriptions')
        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_ == 'HouseDescriptions':
            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_='HouseDescriptions')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='HouseDescriptions', 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_='HouseDescriptions'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='HouseDescriptions', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for house_description_ in self.house_description:
            namespaceprefix_ = self.house_description_nsprefix_ + ':' if (UseCapturedNS_ and self.house_description_nsprefix_) else ''
            house_description_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='house_description', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'house_description':
            obj_ = HouseDescription.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.house_description.append(obj_)
            obj_.original_tagname_ = 'house_description'
# end class HouseDescriptions


class HouseDescription(GeneratedsSuper):
    """HouseDescription -- О
    п
    и
    с
    а
    н
    и
    е
    д
    о
    м
    а
    location_description -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    н
    а
    з
    е
    м
    е
    л
    ь
    н
    о
    м
    у
    ч
    а
    с
    т
    к
    е
    house_number -- Н
    о
    м
    е
    р
    д
    о
    м
    а
    housing_number -- Н
    о
    м
    е
    р
    к
    о
    р
    п
    у
    с
    а
    building_number -- Н
    о
    м
    е
    р
    с
    т
    р
    о
    е
    н
    и
    я
    plan_room_quantity -- П
    л
    а
    н
    и
    р
    у
    е
    м
    о
    е
    к
    о
    л
    и
    ч
    е
    с
    т
    в
    о
    с
    о
    з
    д
    а
    в
    а
    е
    м
    ы
    х
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    plan_rooms_area -- О
    б
    щ
    а
    я
    п
    л
    о
    щ
    а
    д
    ь
    с
    о
    з
    д
    а
    в
    а
    е
    м
    ы
    х
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    (
    к
    в
    .
    м
    .)
    first_contract_mark -- П
    е
    р
    в
    ы
    й
    д
    о
    г
    о
    в
    о
    р
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    first_ddu_date -- Д
    а
    т
    а
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    е
    р
    в
    о
    г
    о
    д
    о
    г
    о
    в
    о
    р
    а
    у
    ч
    а
    с
    т
    и
    я
    в
    д
    о
    л
    е
    в
    о
    м
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    е
    room_descriptions -- О
    п
    и
    с
    а
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, location_description=None, house_number=None, housing_number=None, building_number=None, plan_room_quantity=None, plan_rooms_area=None, first_contract_mark=None, first_ddu_date=None, room_descriptions=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.location_description = location_description
        self.location_description_nsprefix_ = None
        self.house_number = house_number
        self.house_number_nsprefix_ = None
        self.housing_number = housing_number
        self.housing_number_nsprefix_ = None
        self.building_number = building_number
        self.building_number_nsprefix_ = None
        self.plan_room_quantity = plan_room_quantity
        self.validate_PositiveDecimal(self.plan_room_quantity)
        self.plan_room_quantity_nsprefix_ = None
        self.plan_rooms_area = plan_rooms_area
        self.validate_PositiveDecimal(self.plan_rooms_area)
        self.plan_rooms_area_nsprefix_ = None
        self.first_contract_mark = first_contract_mark
        self.first_contract_mark_nsprefix_ = None
        if isinstance(first_ddu_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(first_ddu_date, '%Y-%m-%d').date()
        else:
            initvalue_ = first_ddu_date
        self.first_ddu_date = initvalue_
        self.first_ddu_date_nsprefix_ = None
        self.room_descriptions = room_descriptions
        self.room_descriptions_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, HouseDescription)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if HouseDescription.subclass:
            return HouseDescription.subclass(*args_, **kwargs_)
        else:
            return HouseDescription(*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_location_description(self):
        return self.location_description
    def set_location_description(self, location_description):
        self.location_description = location_description
    def get_house_number(self):
        return self.house_number
    def set_house_number(self, house_number):
        self.house_number = house_number
    def get_housing_number(self):
        return self.housing_number
    def set_housing_number(self, housing_number):
        self.housing_number = housing_number
    def get_building_number(self):
        return self.building_number
    def set_building_number(self, building_number):
        self.building_number = building_number
    def get_plan_room_quantity(self):
        return self.plan_room_quantity
    def set_plan_room_quantity(self, plan_room_quantity):
        self.plan_room_quantity = plan_room_quantity
    def get_plan_rooms_area(self):
        return self.plan_rooms_area
    def set_plan_rooms_area(self, plan_rooms_area):
        self.plan_rooms_area = plan_rooms_area
    def get_first_contract_mark(self):
        return self.first_contract_mark
    def set_first_contract_mark(self, first_contract_mark):
        self.first_contract_mark = first_contract_mark
    def get_first_ddu_date(self):
        return self.first_ddu_date
    def set_first_ddu_date(self, first_ddu_date):
        self.first_ddu_date = first_ddu_date
    def get_room_descriptions(self):
        return self.room_descriptions
    def set_room_descriptions(self, room_descriptions):
        self.room_descriptions = room_descriptions
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.location_description is not None or
            self.house_number is not None or
            self.housing_number is not None or
            self.building_number is not None or
            self.plan_room_quantity is not None or
            self.plan_rooms_area is not None or
            self.first_contract_mark is not None or
            self.first_ddu_date is not None or
            self.room_descriptions is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='HouseDescription', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('HouseDescription')
        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_ == 'HouseDescription':
            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_='HouseDescription')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='HouseDescription', 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_='HouseDescription'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='HouseDescription', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.location_description is not None:
            namespaceprefix_ = self.location_description_nsprefix_ + ':' if (UseCapturedNS_ and self.location_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%slocation_description>%s</%slocation_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.location_description), input_name='location_description')), namespaceprefix_ , eol_))
        if self.house_number is not None:
            namespaceprefix_ = self.house_number_nsprefix_ + ':' if (UseCapturedNS_ and self.house_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%shouse_number>%s</%shouse_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.house_number), input_name='house_number')), namespaceprefix_ , eol_))
        if self.housing_number is not None:
            namespaceprefix_ = self.housing_number_nsprefix_ + ':' if (UseCapturedNS_ and self.housing_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%shousing_number>%s</%shousing_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.housing_number), input_name='housing_number')), namespaceprefix_ , eol_))
        if self.building_number is not None:
            namespaceprefix_ = self.building_number_nsprefix_ + ':' if (UseCapturedNS_ and self.building_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbuilding_number>%s</%sbuilding_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.building_number), input_name='building_number')), namespaceprefix_ , eol_))
        if self.plan_room_quantity is not None:
            namespaceprefix_ = self.plan_room_quantity_nsprefix_ + ':' if (UseCapturedNS_ and self.plan_room_quantity_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%splan_room_quantity>%s</%splan_room_quantity>%s' % (namespaceprefix_ , self.gds_format_decimal(self.plan_room_quantity, input_name='plan_room_quantity'), namespaceprefix_ , eol_))
        if self.plan_rooms_area is not None:
            namespaceprefix_ = self.plan_rooms_area_nsprefix_ + ':' if (UseCapturedNS_ and self.plan_rooms_area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%splan_rooms_area>%s</%splan_rooms_area>%s' % (namespaceprefix_ , self.gds_format_decimal(self.plan_rooms_area, input_name='plan_rooms_area'), namespaceprefix_ , eol_))
        if self.first_contract_mark is not None:
            namespaceprefix_ = self.first_contract_mark_nsprefix_ + ':' if (UseCapturedNS_ and self.first_contract_mark_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfirst_contract_mark>%s</%sfirst_contract_mark>%s' % (namespaceprefix_ , self.gds_format_boolean(self.first_contract_mark, input_name='first_contract_mark'), namespaceprefix_ , eol_))
        if self.first_ddu_date is not None:
            namespaceprefix_ = self.first_ddu_date_nsprefix_ + ':' if (UseCapturedNS_ and self.first_ddu_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfirst_ddu_date>%s</%sfirst_ddu_date>%s' % (namespaceprefix_ , self.gds_format_date(self.first_ddu_date, input_name='first_ddu_date'), namespaceprefix_ , eol_))
        if self.room_descriptions is not None:
            namespaceprefix_ = self.room_descriptions_nsprefix_ + ':' if (UseCapturedNS_ and self.room_descriptions_nsprefix_) else ''
            self.room_descriptions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_descriptions', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'location_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'location_description')
            value_ = self.gds_validate_string(value_, node, 'location_description')
            self.location_description = value_
            self.location_description_nsprefix_ = child_.prefix
        elif nodeName_ == 'house_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'house_number')
            value_ = self.gds_validate_string(value_, node, 'house_number')
            self.house_number = value_
            self.house_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'housing_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'housing_number')
            value_ = self.gds_validate_string(value_, node, 'housing_number')
            self.housing_number = value_
            self.housing_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'building_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'building_number')
            value_ = self.gds_validate_string(value_, node, 'building_number')
            self.building_number = value_
            self.building_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'plan_room_quantity' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'plan_room_quantity')
            fval_ = self.gds_validate_decimal(fval_, node, 'plan_room_quantity')
            self.plan_room_quantity = fval_
            self.plan_room_quantity_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.plan_room_quantity)
        elif nodeName_ == 'plan_rooms_area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'plan_rooms_area')
            fval_ = self.gds_validate_decimal(fval_, node, 'plan_rooms_area')
            self.plan_rooms_area = fval_
            self.plan_rooms_area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.plan_rooms_area)
        elif nodeName_ == 'first_contract_mark':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'first_contract_mark')
            ival_ = self.gds_validate_boolean(ival_, node, 'first_contract_mark')
            self.first_contract_mark = ival_
            self.first_contract_mark_nsprefix_ = child_.prefix
        elif nodeName_ == 'first_ddu_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.first_ddu_date = dval_
            self.first_ddu_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'room_descriptions':
            obj_ = RoomDescriptions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_descriptions = obj_
            obj_.original_tagname_ = 'room_descriptions'
# end class HouseDescription


class AnotherGuarantors(GeneratedsSuper):
    """AnotherGuarantors -- П
    о
    р
    у
    ч
    и
    т
    е
    л
    и
    /
    с
    о
    п
    о
    р
    у
    ч
    и
    т
    е
    л
    и
    ,
    з
    а
    к
    л
    ю
    ч
    и
    в
    ш
    и
    е
    д
    о
    г
    о
    в
    о
    р
    п
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    п
    о
    о
    б
    я
    з
    а
    т
    е
    л
    ь
    с
    т
    в
    а
    м
    з
    а
    с
    т
    р
    о
    й
    щ
    и
    к
    а
    ,
    р
    а
    з
    м
    е
    р
    у
    с
    т
    а
    в
    н
    о
    г
    о
    к
    а
    п
    и
    т
    а
    л
    а
    к
    о
    т
    о
    р
    о
    г
    о
    н
    е
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    у
    е
    т
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    м
    214-
    Ф
    З
    another_guarantor -- П
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    /
    с
    о
    п
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    ,
    з
    а
    к
    л
    ю
    ч
    и
    в
    ш
    и
    й
    д
    о
    г
    о
    в
    о
    р
    п
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    п
    о
    о
    б
    я
    з
    а
    т
    е
    л
    ь
    с
    т
    в
    а
    м
    з
    а
    с
    т
    р
    о
    й
    щ
    и
    к
    а
    ,
    р
    а
    з
    м
    е
    р
    у
    с
    т
    а
    в
    н
    о
    г
    о
    к
    а
    п
    и
    т
    а
    л
    а
    к
    о
    т
    о
    р
    о
    г
    о
    н
    е
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    у
    е
    т
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    м
    214-
    Ф
    З
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, another_guarantor=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 another_guarantor is None:
            self.another_guarantor = []
        else:
            self.another_guarantor = another_guarantor
        self.another_guarantor_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AnotherGuarantors)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AnotherGuarantors.subclass:
            return AnotherGuarantors.subclass(*args_, **kwargs_)
        else:
            return AnotherGuarantors(*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_another_guarantor(self):
        return self.another_guarantor
    def set_another_guarantor(self, another_guarantor):
        self.another_guarantor = another_guarantor
    def add_another_guarantor(self, value):
        self.another_guarantor.append(value)
    def insert_another_guarantor_at(self, index, value):
        self.another_guarantor.insert(index, value)
    def replace_another_guarantor_at(self, index, value):
        self.another_guarantor[index] = value
    def has__content(self):
        if (
            self.another_guarantor
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherGuarantors', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AnotherGuarantors')
        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_ == 'AnotherGuarantors':
            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_='AnotherGuarantors')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AnotherGuarantors', 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_='AnotherGuarantors'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherGuarantors', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for another_guarantor_ in self.another_guarantor:
            namespaceprefix_ = self.another_guarantor_nsprefix_ + ':' if (UseCapturedNS_ and self.another_guarantor_nsprefix_) else ''
            another_guarantor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='another_guarantor', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'another_guarantor':
            obj_ = AnotherGuarantor.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.another_guarantor.append(obj_)
            obj_.original_tagname_ = 'another_guarantor'
# end class AnotherGuarantors


class AnotherGuarantor(GeneratedsSuper):
    """AnotherGuarantor -- П
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    /
    с
    о
    п
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    ,
    з
    а
    к
    л
    ю
    ч
    и
    в
    ш
    и
    й
    д
    о
    г
    о
    в
    о
    р
    п
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    п
    о
    о
    б
    я
    з
    а
    т
    е
    л
    ь
    с
    т
    в
    а
    м
    з
    а
    с
    т
    р
    о
    й
    щ
    и
    к
    а
    ,
    р
    а
    з
    м
    е
    р
    у
    с
    т
    а
    в
    н
    о
    г
    о
    к
    а
    п
    и
    т
    а
    л
    а
    к
    о
    т
    о
    р
    о
    г
    о
    н
    е
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    у
    е
    т
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    м
    214-
    Ф
    З
    another_guarantor_name -- П
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    /
    с
    о
    п
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, another_guarantor_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.another_guarantor_name = another_guarantor_name
        self.another_guarantor_name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, AnotherGuarantor)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if AnotherGuarantor.subclass:
            return AnotherGuarantor.subclass(*args_, **kwargs_)
        else:
            return AnotherGuarantor(*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_another_guarantor_name(self):
        return self.another_guarantor_name
    def set_another_guarantor_name(self, another_guarantor_name):
        self.another_guarantor_name = another_guarantor_name
    def has__content(self):
        if (
            self.another_guarantor_name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherGuarantor', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AnotherGuarantor')
        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_ == 'AnotherGuarantor':
            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_='AnotherGuarantor')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AnotherGuarantor', 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_='AnotherGuarantor'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AnotherGuarantor', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.another_guarantor_name is not None:
            namespaceprefix_ = self.another_guarantor_name_nsprefix_ + ':' if (UseCapturedNS_ and self.another_guarantor_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sanother_guarantor_name>%s</%sanother_guarantor_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.another_guarantor_name), input_name='another_guarantor_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'another_guarantor_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'another_guarantor_name')
            value_ = self.gds_validate_string(value_, node, 'another_guarantor_name')
            self.another_guarantor_name = value_
            self.another_guarantor_name_nsprefix_ = child_.prefix
# end class AnotherGuarantor


class Enforcement(GeneratedsSuper):
    """Enforcement -- О
    б
    е
    с
    п
    е
    ч
    е
    н
    и
    е
    и
    с
    п
    о
    л
    н
    е
    н
    и
    я
    insurance -- С
    т
    р
    а
    х
    о
    в
    а
    н
    и
    е
    guarantee -- П
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    с
    т
    в
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, insurance=None, guarantee=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.insurance = insurance
        self.insurance_nsprefix_ = None
        self.guarantee = guarantee
        self.guarantee_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Enforcement)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Enforcement.subclass:
            return Enforcement.subclass(*args_, **kwargs_)
        else:
            return Enforcement(*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_insurance(self):
        return self.insurance
    def set_insurance(self, insurance):
        self.insurance = insurance
    def get_guarantee(self):
        return self.guarantee
    def set_guarantee(self, guarantee):
        self.guarantee = guarantee
    def has__content(self):
        if (
            self.insurance is not None or
            self.guarantee is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Enforcement', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Enforcement')
        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_ == 'Enforcement':
            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_='Enforcement')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Enforcement', 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_='Enforcement'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Enforcement', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.insurance is not None:
            namespaceprefix_ = self.insurance_nsprefix_ + ':' if (UseCapturedNS_ and self.insurance_nsprefix_) else ''
            self.insurance.export(outfile, level, namespaceprefix_, namespacedef_='', name_='insurance', pretty_print=pretty_print)
        if self.guarantee is not None:
            namespaceprefix_ = self.guarantee_nsprefix_ + ':' if (UseCapturedNS_ and self.guarantee_nsprefix_) else ''
            self.guarantee.export(outfile, level, namespaceprefix_, namespacedef_='', name_='guarantee', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'insurance':
            obj_ = Insurance.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.insurance = obj_
            obj_.original_tagname_ = 'insurance'
        elif nodeName_ == 'guarantee':
            obj_ = Guarantee.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.guarantee = obj_
            obj_.original_tagname_ = 'guarantee'
# end class Enforcement


class Insurance(GeneratedsSuper):
    """Insurance -- С
    т
    р
    а
    х
    о
    в
    а
    н
    и
    е
    insurer -- С
    т
    р
    а
    х
    о
    в
    щ
    и
    к
    (
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    о
    С
    п
    и
    с
    к
    о
    м
    с
    т
    р
    а
    х
    о
    в
    щ
    и
    к
    о
    в
    ,
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    у
    ю
    щ
    и
    х
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    м
    214-
    Ф
    З
    )
    insurance_sum -- С
    т
    р
    а
    х
    о
    в
    а
    я
    с
    у
    м
    м
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, insurer=None, insurance_sum=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.insurer = insurer
        self.insurer_nsprefix_ = None
        self.insurance_sum = insurance_sum
        self.validate_PositiveDecimal(self.insurance_sum)
        self.insurance_sum_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Insurance)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Insurance.subclass:
            return Insurance.subclass(*args_, **kwargs_)
        else:
            return Insurance(*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_insurer(self):
        return self.insurer
    def set_insurer(self, insurer):
        self.insurer = insurer
    def get_insurance_sum(self):
        return self.insurance_sum
    def set_insurance_sum(self, insurance_sum):
        self.insurance_sum = insurance_sum
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.insurer is not None or
            self.insurance_sum is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Insurance', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Insurance')
        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_ == 'Insurance':
            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_='Insurance')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Insurance', 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_='Insurance'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Insurance', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.insurer is not None:
            namespaceprefix_ = self.insurer_nsprefix_ + ':' if (UseCapturedNS_ and self.insurer_nsprefix_) else ''
            self.insurer.export(outfile, level, namespaceprefix_, namespacedef_='', name_='insurer', pretty_print=pretty_print)
        if self.insurance_sum is not None:
            namespaceprefix_ = self.insurance_sum_nsprefix_ + ':' if (UseCapturedNS_ and self.insurance_sum_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sinsurance_sum>%s</%sinsurance_sum>%s' % (namespaceprefix_ , self.gds_format_decimal(self.insurance_sum, input_name='insurance_sum'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'insurer':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.insurer = obj_
            obj_.original_tagname_ = 'insurer'
        elif nodeName_ == 'insurance_sum' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'insurance_sum')
            fval_ = self.gds_validate_decimal(fval_, node, 'insurance_sum')
            self.insurance_sum = fval_
            self.insurance_sum_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.insurance_sum)
# end class Insurance


class Guarantee(GeneratedsSuper):
    """Guarantee -- П
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    с
    т
    в
    о
    guarantor -- П
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    guarantee_sum -- C
    у
    м
    м
    а
    (
    р
    а
    з
    м
    е
    р
    )
    п
    р
    е
    д
    о
    с
    т
    а
    в
    л
    я
    е
    м
    о
    г
    о
    п
    о
    р
    у
    ч
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, guarantor=None, guarantee_sum=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.guarantor = guarantor
        self.guarantor_nsprefix_ = None
        self.guarantee_sum = guarantee_sum
        self.validate_PositiveDecimal(self.guarantee_sum)
        self.guarantee_sum_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Guarantee)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Guarantee.subclass:
            return Guarantee.subclass(*args_, **kwargs_)
        else:
            return Guarantee(*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_guarantor(self):
        return self.guarantor
    def set_guarantor(self, guarantor):
        self.guarantor = guarantor
    def get_guarantee_sum(self):
        return self.guarantee_sum
    def set_guarantee_sum(self, guarantee_sum):
        self.guarantee_sum = guarantee_sum
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.guarantor is not None or
            self.guarantee_sum is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Guarantee', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Guarantee')
        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_ == 'Guarantee':
            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_='Guarantee')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Guarantee', 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_='Guarantee'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='Guarantee', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.guarantor is not None:
            namespaceprefix_ = self.guarantor_nsprefix_ + ':' if (UseCapturedNS_ and self.guarantor_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sguarantor>%s</%sguarantor>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.guarantor), input_name='guarantor')), namespaceprefix_ , eol_))
        if self.guarantee_sum is not None:
            namespaceprefix_ = self.guarantee_sum_nsprefix_ + ':' if (UseCapturedNS_ and self.guarantee_sum_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sguarantee_sum>%s</%sguarantee_sum>%s' % (namespaceprefix_ , self.gds_format_decimal(self.guarantee_sum, input_name='guarantee_sum'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'guarantor':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'guarantor')
            value_ = self.gds_validate_string(value_, node, 'guarantor')
            self.guarantor = value_
            self.guarantor_nsprefix_ = child_.prefix
        elif nodeName_ == 'guarantee_sum' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'guarantee_sum')
            fval_ = self.gds_validate_decimal(fval_, node, 'guarantee_sum')
            self.guarantee_sum = fval_
            self.guarantee_sum_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.guarantee_sum)
# end class Guarantee


class RoomDescriptions(GeneratedsSuper):
    """RoomDescriptions -- О
    п
    и
    с
    а
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    й
    room_description -- О
    п
    и
    с
    а
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, room_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
        if room_description is None:
            self.room_description = []
        else:
            self.room_description = room_description
        self.room_description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomDescriptions)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomDescriptions.subclass:
            return RoomDescriptions.subclass(*args_, **kwargs_)
        else:
            return RoomDescriptions(*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_room_description(self):
        return self.room_description
    def set_room_description(self, room_description):
        self.room_description = room_description
    def add_room_description(self, value):
        self.room_description.append(value)
    def insert_room_description_at(self, index, value):
        self.room_description.insert(index, value)
    def replace_room_description_at(self, index, value):
        self.room_description[index] = value
    def has__content(self):
        if (
            self.room_description
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomDescriptions', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomDescriptions')
        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_ == 'RoomDescriptions':
            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_='RoomDescriptions')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomDescriptions', 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_='RoomDescriptions'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomDescriptions', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for room_description_ in self.room_description:
            namespaceprefix_ = self.room_description_nsprefix_ + ':' if (UseCapturedNS_ and self.room_description_nsprefix_) else ''
            room_description_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_description', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'room_description':
            obj_ = RoomDescription.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_description.append(obj_)
            obj_.original_tagname_ = 'room_description'
# end class RoomDescriptions


class RoomDescription(GeneratedsSuper):
    """RoomDescription -- О
    п
    и
    с
    а
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    room_name -- Н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    room_number -- Н
    о
    м
    е
    р
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    floor_number -- Н
    о
    м
    е
    р
    э
    т
    а
    ж
    а
    plan_number -- Н
    о
    м
    е
    р
    н
    а
    п
    л
    а
    н
    е
    room_area -- П
    л
    о
    щ
    а
    д
    ь
    (
    к
    в
    .
    м
    .)
    purpose -- Н
    а
    з
    н
    а
    ч
    е
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    transfer_deadline -- С
    р
    о
    к
    п
    е
    р
    е
    д
    а
    ч
    и
    з
    а
    с
    т
    р
    о
    й
    щ
    и
    к
    о
    м
    о
    б
    ъ
    е
    к
    т
    а
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    у
    ч
    а
    с
    т
    н
    и
    к
    у
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    guarantee_period -- Г
    а
    р
    а
    н
    т
    и
    й
    н
    ы
    й
    с
    р
    о
    к
    н
    а
    о
    б
    ъ
    е
    к
    т
    д
    о
    л
    е
    в
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    date_become_oks -- Д
    а
    т
    а
    п
    р
    е
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    я
    в
    О
    К
    С
    cad_number -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ,
    п
    р
    и
    с
    в
    о
    е
    н
    н
    ы
    й
    о
    б
    ъ
    е
    к
    т
    у
    right_numbers -- З
    а
    р
    е
    г
    и
    с
    т
    р
    о
    в
    а
    н
    н
    ы
    е
    п
    р
    а
    в
    а
    text_description -- Т
    е
    к
    с
    т
    о
    в
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, room_name=None, room_number=None, floor_number=None, plan_number=None, room_area=None, purpose=None, transfer_deadline=None, guarantee_period=None, date_become_oks=None, cad_number=None, right_numbers=None, text_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.room_name = room_name
        self.room_name_nsprefix_ = None
        self.room_number = room_number
        self.room_number_nsprefix_ = None
        self.floor_number = floor_number
        self.floor_number_nsprefix_ = None
        self.plan_number = plan_number
        self.plan_number_nsprefix_ = None
        self.room_area = room_area
        self.validate_PositiveDecimal(self.room_area)
        self.room_area_nsprefix_ = None
        self.purpose = purpose
        self.purpose_nsprefix_ = None
        self.transfer_deadline = transfer_deadline
        self.transfer_deadline_nsprefix_ = None
        self.guarantee_period = guarantee_period
        self.guarantee_period_nsprefix_ = None
        if isinstance(date_become_oks, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_become_oks, '%Y-%m-%d').date()
        else:
            initvalue_ = date_become_oks
        self.date_become_oks = initvalue_
        self.date_become_oks_nsprefix_ = None
        self.cad_number = cad_number
        self.cad_number_nsprefix_ = None
        self.right_numbers = right_numbers
        self.right_numbers_nsprefix_ = None
        self.text_description = text_description
        self.validate_MultiLiner(self.text_description)
        self.text_description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, RoomDescription)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if RoomDescription.subclass:
            return RoomDescription.subclass(*args_, **kwargs_)
        else:
            return RoomDescription(*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_room_name(self):
        return self.room_name
    def set_room_name(self, room_name):
        self.room_name = room_name
    def get_room_number(self):
        return self.room_number
    def set_room_number(self, room_number):
        self.room_number = room_number
    def get_floor_number(self):
        return self.floor_number
    def set_floor_number(self, floor_number):
        self.floor_number = floor_number
    def get_plan_number(self):
        return self.plan_number
    def set_plan_number(self, plan_number):
        self.plan_number = plan_number
    def get_room_area(self):
        return self.room_area
    def set_room_area(self, room_area):
        self.room_area = room_area
    def get_purpose(self):
        return self.purpose
    def set_purpose(self, purpose):
        self.purpose = purpose
    def get_transfer_deadline(self):
        return self.transfer_deadline
    def set_transfer_deadline(self, transfer_deadline):
        self.transfer_deadline = transfer_deadline
    def get_guarantee_period(self):
        return self.guarantee_period
    def set_guarantee_period(self, guarantee_period):
        self.guarantee_period = guarantee_period
    def get_date_become_oks(self):
        return self.date_become_oks
    def set_date_become_oks(self, date_become_oks):
        self.date_become_oks = date_become_oks
    def get_cad_number(self):
        return self.cad_number
    def set_cad_number(self, cad_number):
        self.cad_number = cad_number
    def get_right_numbers(self):
        return self.right_numbers
    def set_right_numbers(self, right_numbers):
        self.right_numbers = right_numbers
    def get_text_description(self):
        return self.text_description
    def set_text_description(self, text_description):
        self.text_description = text_description
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.room_name is not None or
            self.room_number is not None or
            self.floor_number is not None or
            self.plan_number is not None or
            self.room_area is not None or
            self.purpose is not None or
            self.transfer_deadline is not None or
            self.guarantee_period is not None or
            self.date_become_oks is not None or
            self.cad_number is not None or
            self.right_numbers is not None or
            self.text_description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomDescription', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RoomDescription')
        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_ == 'RoomDescription':
            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_='RoomDescription')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RoomDescription', 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_='RoomDescription'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='RoomDescription', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.room_name is not None:
            namespaceprefix_ = self.room_name_nsprefix_ + ':' if (UseCapturedNS_ and self.room_name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sroom_name>%s</%sroom_name>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.room_name), input_name='room_name')), namespaceprefix_ , eol_))
        if self.room_number is not None:
            namespaceprefix_ = self.room_number_nsprefix_ + ':' if (UseCapturedNS_ and self.room_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sroom_number>%s</%sroom_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.room_number), input_name='room_number')), namespaceprefix_ , eol_))
        if self.floor_number is not None:
            namespaceprefix_ = self.floor_number_nsprefix_ + ':' if (UseCapturedNS_ and self.floor_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfloor_number>%s</%sfloor_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.floor_number), input_name='floor_number')), namespaceprefix_ , eol_))
        if self.plan_number is not None:
            namespaceprefix_ = self.plan_number_nsprefix_ + ':' if (UseCapturedNS_ and self.plan_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%splan_number>%s</%splan_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.plan_number), input_name='plan_number')), namespaceprefix_ , eol_))
        if self.room_area is not None:
            namespaceprefix_ = self.room_area_nsprefix_ + ':' if (UseCapturedNS_ and self.room_area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sroom_area>%s</%sroom_area>%s' % (namespaceprefix_ , self.gds_format_decimal(self.room_area, input_name='room_area'), namespaceprefix_ , eol_))
        if self.purpose is not None:
            namespaceprefix_ = self.purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.purpose_nsprefix_) else ''
            self.purpose.export(outfile, level, namespaceprefix_, namespacedef_='', name_='purpose', pretty_print=pretty_print)
        if self.transfer_deadline is not None:
            namespaceprefix_ = self.transfer_deadline_nsprefix_ + ':' if (UseCapturedNS_ and self.transfer_deadline_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stransfer_deadline>%s</%stransfer_deadline>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.transfer_deadline), input_name='transfer_deadline')), namespaceprefix_ , eol_))
        if self.guarantee_period is not None:
            namespaceprefix_ = self.guarantee_period_nsprefix_ + ':' if (UseCapturedNS_ and self.guarantee_period_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sguarantee_period>%s</%sguarantee_period>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.guarantee_period), input_name='guarantee_period')), namespaceprefix_ , eol_))
        if self.date_become_oks is not None:
            namespaceprefix_ = self.date_become_oks_nsprefix_ + ':' if (UseCapturedNS_ and self.date_become_oks_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_become_oks>%s</%sdate_become_oks>%s' % (namespaceprefix_ , self.gds_format_date(self.date_become_oks, input_name='date_become_oks'), namespaceprefix_ , eol_))
        if self.cad_number is not None:
            namespaceprefix_ = self.cad_number_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scad_number>%s</%scad_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.cad_number), input_name='cad_number')), namespaceprefix_ , eol_))
        if self.right_numbers is not None:
            namespaceprefix_ = self.right_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.right_numbers_nsprefix_) else ''
            self.right_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_numbers', pretty_print=pretty_print)
        if self.text_description is not None:
            namespaceprefix_ = self.text_description_nsprefix_ + ':' if (UseCapturedNS_ and self.text_description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%stext_description>%s</%stext_description>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.text_description), input_name='text_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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'room_name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'room_name')
            value_ = self.gds_validate_string(value_, node, 'room_name')
            self.room_name = value_
            self.room_name_nsprefix_ = child_.prefix
        elif nodeName_ == 'room_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'room_number')
            value_ = self.gds_validate_string(value_, node, 'room_number')
            self.room_number = value_
            self.room_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'floor_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'floor_number')
            value_ = self.gds_validate_string(value_, node, 'floor_number')
            self.floor_number = value_
            self.floor_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'plan_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'plan_number')
            value_ = self.gds_validate_string(value_, node, 'plan_number')
            self.plan_number = value_
            self.plan_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'room_area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'room_area')
            fval_ = self.gds_validate_decimal(fval_, node, 'room_area')
            self.room_area = fval_
            self.room_area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.room_area)
        elif nodeName_ == 'purpose':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.purpose = obj_
            obj_.original_tagname_ = 'purpose'
        elif nodeName_ == 'transfer_deadline':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'transfer_deadline')
            value_ = self.gds_validate_string(value_, node, 'transfer_deadline')
            self.transfer_deadline = value_
            self.transfer_deadline_nsprefix_ = child_.prefix
        elif nodeName_ == 'guarantee_period':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'guarantee_period')
            value_ = self.gds_validate_string(value_, node, 'guarantee_period')
            self.guarantee_period = value_
            self.guarantee_period_nsprefix_ = child_.prefix
        elif nodeName_ == 'date_become_oks':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_become_oks = dval_
            self.date_become_oks_nsprefix_ = child_.prefix
        elif nodeName_ == 'cad_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'cad_number')
            value_ = self.gds_validate_string(value_, node, 'cad_number')
            self.cad_number = value_
            self.cad_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'right_numbers':
            obj_ = right_numbersType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_numbers = obj_
            obj_.original_tagname_ = 'right_numbers'
        elif nodeName_ == 'text_description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'text_description')
            value_ = self.gds_validate_string(value_, node, 'text_description')
            self.text_description = value_
            self.text_description_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.text_description)
# end class RoomDescription


class group_top_requisitesType(GeneratedsSuper):
    """group_top_requisitesType -- Г
    р
    у
    п
    п
    а
    в
    е
    р
    х
    н
    и
    х
    р
    е
    к
    в
    и
    з
    и
    т
    о
    в
    organ_registr_rights -- П
    о
    л
    н
    о
    е
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    р
    г
    а
    н
    а
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    р
    а
    в
    date_formation -- Д
    а
    т
    а
    ф
    о
    р
    м
    и
    р
    о
    в
    а
    н
    и
    я
    в
    ы
    п
    и
    с
    к
    и
    registration_number -- Р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    о
    н
    н
    ы
    й
    н
    о
    м
    е
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, organ_registr_rights=None, date_formation=None, registration_number=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.organ_registr_rights = organ_registr_rights
        self.organ_registr_rights_nsprefix_ = None
        if isinstance(date_formation, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_formation, '%Y-%m-%d').date()
        else:
            initvalue_ = date_formation
        self.date_formation = initvalue_
        self.date_formation_nsprefix_ = None
        self.registration_number = registration_number
        self.registration_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, group_top_requisitesType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if group_top_requisitesType.subclass:
            return group_top_requisitesType.subclass(*args_, **kwargs_)
        else:
            return group_top_requisitesType(*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_organ_registr_rights(self):
        return self.organ_registr_rights
    def set_organ_registr_rights(self, organ_registr_rights):
        self.organ_registr_rights = organ_registr_rights
    def get_date_formation(self):
        return self.date_formation
    def set_date_formation(self, date_formation):
        self.date_formation = date_formation
    def get_registration_number(self):
        return self.registration_number
    def set_registration_number(self, registration_number):
        self.registration_number = registration_number
    def has__content(self):
        if (
            self.organ_registr_rights is not None or
            self.date_formation is not None or
            self.registration_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='group_top_requisitesType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('group_top_requisitesType')
        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_ == 'group_top_requisitesType':
            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_='group_top_requisitesType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='group_top_requisitesType', 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_='group_top_requisitesType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='group_top_requisitesType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.organ_registr_rights is not None:
            namespaceprefix_ = self.organ_registr_rights_nsprefix_ + ':' if (UseCapturedNS_ and self.organ_registr_rights_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sorgan_registr_rights>%s</%sorgan_registr_rights>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.organ_registr_rights), input_name='organ_registr_rights')), namespaceprefix_ , eol_))
        if self.date_formation is not None:
            namespaceprefix_ = self.date_formation_nsprefix_ + ':' if (UseCapturedNS_ and self.date_formation_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_formation>%s</%sdate_formation>%s' % (namespaceprefix_ , self.gds_format_date(self.date_formation, input_name='date_formation'), namespaceprefix_ , eol_))
        if self.registration_number is not None:
            namespaceprefix_ = self.registration_number_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_number>%s</%sregistration_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.registration_number), input_name='registration_number')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'organ_registr_rights':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'organ_registr_rights')
            value_ = self.gds_validate_string(value_, node, 'organ_registr_rights')
            self.organ_registr_rights = value_
            self.organ_registr_rights_nsprefix_ = child_.prefix
        elif nodeName_ == 'date_formation':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_formation = dval_
            self.date_formation_nsprefix_ = child_.prefix
        elif nodeName_ == 'registration_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'registration_number')
            value_ = self.gds_validate_string(value_, node, 'registration_number')
            self.registration_number = value_
            self.registration_number_nsprefix_ = child_.prefix
# end class group_top_requisitesType


class group_lower_requisitesType(GeneratedsSuper):
    """group_lower_requisitesType -- Г
    р
    у
    п
    п
    а
    н
    и
    ж
    н
    и
    х
    р
    е
    к
    в
    и
    з
    и
    т
    о
    в
    full_name_position -- П
    о
    л
    н
    о
    е
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    д
    о
    л
    ж
    н
    о
    с
    т
    и
    initials_surname -- И
    н
    и
    ц
    и
    а
    л
    ы
    ,
    ф
    а
    м
    и
    л
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, full_name_position=None, initials_surname=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.full_name_position = full_name_position
        self.full_name_position_nsprefix_ = None
        self.initials_surname = initials_surname
        self.initials_surname_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, group_lower_requisitesType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if group_lower_requisitesType.subclass:
            return group_lower_requisitesType.subclass(*args_, **kwargs_)
        else:
            return group_lower_requisitesType(*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_full_name_position(self):
        return self.full_name_position
    def set_full_name_position(self, full_name_position):
        self.full_name_position = full_name_position
    def get_initials_surname(self):
        return self.initials_surname
    def set_initials_surname(self, initials_surname):
        self.initials_surname = initials_surname
    def has__content(self):
        if (
            self.full_name_position is not None or
            self.initials_surname is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='group_lower_requisitesType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('group_lower_requisitesType')
        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_ == 'group_lower_requisitesType':
            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_='group_lower_requisitesType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='group_lower_requisitesType', 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_='group_lower_requisitesType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='group_lower_requisitesType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.full_name_position is not None:
            namespaceprefix_ = self.full_name_position_nsprefix_ + ':' if (UseCapturedNS_ and self.full_name_position_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfull_name_position>%s</%sfull_name_position>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.full_name_position), input_name='full_name_position')), namespaceprefix_ , eol_))
        if self.initials_surname is not None:
            namespaceprefix_ = self.initials_surname_nsprefix_ + ':' if (UseCapturedNS_ and self.initials_surname_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sinitials_surname>%s</%sinitials_surname>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.initials_surname), input_name='initials_surname')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'full_name_position':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'full_name_position')
            value_ = self.gds_validate_string(value_, node, 'full_name_position')
            self.full_name_position = value_
            self.full_name_position_nsprefix_ = child_.prefix
        elif nodeName_ == 'initials_surname':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'initials_surname')
            value_ = self.gds_validate_string(value_, node, 'initials_surname')
            self.initials_surname = value_
            self.initials_surname_nsprefix_ = child_.prefix
# end class group_lower_requisitesType


class group_top_requisitesType1(GeneratedsSuper):
    """group_top_requisitesType1 -- Г
    р
    у
    п
    п
    а
    в
    е
    р
    х
    н
    и
    х
    р
    е
    к
    в
    и
    з
    и
    т
    о
    в
    organ_registr_rights -- П
    о
    л
    н
    о
    е
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    о
    р
    г
    а
    н
    а
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    п
    р
    а
    в
    date_formation -- Д
    а
    т
    а
    ф
    о
    р
    м
    и
    р
    о
    в
    а
    н
    и
    я
    в
    ы
    п
    и
    с
    к
    и
    registration_number -- Р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    о
    н
    н
    ы
    й
    н
    о
    м
    е
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, organ_registr_rights=None, date_formation=None, registration_number=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.organ_registr_rights = organ_registr_rights
        self.organ_registr_rights_nsprefix_ = None
        if isinstance(date_formation, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(date_formation, '%Y-%m-%d').date()
        else:
            initvalue_ = date_formation
        self.date_formation = initvalue_
        self.date_formation_nsprefix_ = None
        self.registration_number = registration_number
        self.registration_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, group_top_requisitesType1)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if group_top_requisitesType1.subclass:
            return group_top_requisitesType1.subclass(*args_, **kwargs_)
        else:
            return group_top_requisitesType1(*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_organ_registr_rights(self):
        return self.organ_registr_rights
    def set_organ_registr_rights(self, organ_registr_rights):
        self.organ_registr_rights = organ_registr_rights
    def get_date_formation(self):
        return self.date_formation
    def set_date_formation(self, date_formation):
        self.date_formation = date_formation
    def get_registration_number(self):
        return self.registration_number
    def set_registration_number(self, registration_number):
        self.registration_number = registration_number
    def has__content(self):
        if (
            self.organ_registr_rights is not None or
            self.date_formation is not None or
            self.registration_number is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='group_top_requisitesType1', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('group_top_requisitesType1')
        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_ == 'group_top_requisitesType1':
            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_='group_top_requisitesType1')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='group_top_requisitesType1', 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_='group_top_requisitesType1'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='group_top_requisitesType1', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.organ_registr_rights is not None:
            namespaceprefix_ = self.organ_registr_rights_nsprefix_ + ':' if (UseCapturedNS_ and self.organ_registr_rights_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sorgan_registr_rights>%s</%sorgan_registr_rights>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.organ_registr_rights), input_name='organ_registr_rights')), namespaceprefix_ , eol_))
        if self.date_formation is not None:
            namespaceprefix_ = self.date_formation_nsprefix_ + ':' if (UseCapturedNS_ and self.date_formation_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdate_formation>%s</%sdate_formation>%s' % (namespaceprefix_ , self.gds_format_date(self.date_formation, input_name='date_formation'), namespaceprefix_ , eol_))
        if self.registration_number is not None:
            namespaceprefix_ = self.registration_number_nsprefix_ + ':' if (UseCapturedNS_ and self.registration_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sregistration_number>%s</%sregistration_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.registration_number), input_name='registration_number')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'organ_registr_rights':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'organ_registr_rights')
            value_ = self.gds_validate_string(value_, node, 'organ_registr_rights')
            self.organ_registr_rights = value_
            self.organ_registr_rights_nsprefix_ = child_.prefix
        elif nodeName_ == 'date_formation':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.date_formation = dval_
            self.date_formation_nsprefix_ = child_.prefix
        elif nodeName_ == 'registration_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'registration_number')
            value_ = self.gds_validate_string(value_, node, 'registration_number')
            self.registration_number = value_
            self.registration_number_nsprefix_ = child_.prefix
# end class group_top_requisitesType1


class group_lower_requisitesType2(GeneratedsSuper):
    """group_lower_requisitesType2 -- Г
    р
    у
    п
    п
    а
    н
    и
    ж
    н
    и
    х
    р
    е
    к
    в
    и
    з
    и
    т
    о
    в
    full_name_position -- П
    о
    л
    н
    о
    е
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    д
    о
    л
    ж
    н
    о
    с
    т
    и
    initials_surname -- И
    н
    и
    ц
    и
    а
    л
    ы
    ,
    ф
    а
    м
    и
    л
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, full_name_position=None, initials_surname=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.full_name_position = full_name_position
        self.full_name_position_nsprefix_ = None
        self.initials_surname = initials_surname
        self.initials_surname_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, group_lower_requisitesType2)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if group_lower_requisitesType2.subclass:
            return group_lower_requisitesType2.subclass(*args_, **kwargs_)
        else:
            return group_lower_requisitesType2(*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_full_name_position(self):
        return self.full_name_position
    def set_full_name_position(self, full_name_position):
        self.full_name_position = full_name_position
    def get_initials_surname(self):
        return self.initials_surname
    def set_initials_surname(self, initials_surname):
        self.initials_surname = initials_surname
    def has__content(self):
        if (
            self.full_name_position is not None or
            self.initials_surname is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='group_lower_requisitesType2', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('group_lower_requisitesType2')
        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_ == 'group_lower_requisitesType2':
            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_='group_lower_requisitesType2')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='group_lower_requisitesType2', 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_='group_lower_requisitesType2'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='group_lower_requisitesType2', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.full_name_position is not None:
            namespaceprefix_ = self.full_name_position_nsprefix_ + ':' if (UseCapturedNS_ and self.full_name_position_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfull_name_position>%s</%sfull_name_position>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.full_name_position), input_name='full_name_position')), namespaceprefix_ , eol_))
        if self.initials_surname is not None:
            namespaceprefix_ = self.initials_surname_nsprefix_ + ':' if (UseCapturedNS_ and self.initials_surname_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sinitials_surname>%s</%sinitials_surname>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.initials_surname), input_name='initials_surname')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'full_name_position':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'full_name_position')
            value_ = self.gds_validate_string(value_, node, 'full_name_position')
            self.full_name_position = value_
            self.full_name_position_nsprefix_ = child_.prefix
        elif nodeName_ == 'initials_surname':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'initials_surname')
            value_ = self.gds_validate_string(value_, node, 'initials_surname')
            self.initials_surname = value_
            self.initials_surname_nsprefix_ = child_.prefix
# end class group_lower_requisitesType2


class heritage_decisionsType(GeneratedsSuper):
    """heritage_decisionsType -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    р
    е
    ш
    е
    н
    и
    й
    heritage_decision -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    р
    е
    ш
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, heritage_decision=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 heritage_decision is None:
            self.heritage_decision = []
        else:
            self.heritage_decision = heritage_decision
        self.heritage_decision_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, heritage_decisionsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if heritage_decisionsType.subclass:
            return heritage_decisionsType.subclass(*args_, **kwargs_)
        else:
            return heritage_decisionsType(*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_heritage_decision(self):
        return self.heritage_decision
    def set_heritage_decision(self, heritage_decision):
        self.heritage_decision = heritage_decision
    def add_heritage_decision(self, value):
        self.heritage_decision.append(value)
    def insert_heritage_decision_at(self, index, value):
        self.heritage_decision.insert(index, value)
    def replace_heritage_decision_at(self, index, value):
        self.heritage_decision[index] = value
    def has__content(self):
        if (
            self.heritage_decision
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='heritage_decisionsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('heritage_decisionsType')
        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_ == 'heritage_decisionsType':
            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_='heritage_decisionsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='heritage_decisionsType', 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_='heritage_decisionsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='heritage_decisionsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for heritage_decision_ in self.heritage_decision:
            namespaceprefix_ = self.heritage_decision_nsprefix_ + ':' if (UseCapturedNS_ and self.heritage_decision_nsprefix_) else ''
            heritage_decision_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='heritage_decision', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'heritage_decision':
            obj_ = DocRequisite.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.heritage_decision.append(obj_)
            obj_.original_tagname_ = 'heritage_decision'
# end class heritage_decisionsType


class categoryType(GeneratedsSuper):
    """categoryType -- К
    а
    т
    е
    г
    о
    р
    и
    я
    type -- В
    и
    д
    к
    а
    т
    е
    г
    о
    р
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, type_=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.type_ = type_
        self.type__nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, categoryType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if categoryType.subclass:
            return categoryType.subclass(*args_, **kwargs_)
        else:
            return categoryType(*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_type(self):
        return self.type_
    def set_type(self, type_):
        self.type_ = type_
    def has__content(self):
        if (
            self.type_ is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='categoryType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('categoryType')
        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_ == 'categoryType':
            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_='categoryType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='categoryType', 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_='categoryType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='categoryType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_ is not None:
            namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else ''
            self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
# end class categoryType


class room_recordType(GeneratedsSuper):
    """room_recordType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    о
    м
    е
    щ
    е
    н
    и
    и
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    )
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    п
    о
    м
    е
    щ
    е
    н
    и
    я
    location_in_build -- Р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    п
    р
    е
    д
    е
    л
    а
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, location_in_build=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.location_in_build = location_in_build
        self.location_in_build_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, room_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if room_recordType.subclass:
            return room_recordType.subclass(*args_, **kwargs_)
        else:
            return room_recordType(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_location_in_build(self):
        return self.location_in_build
    def set_location_in_build(self, location_in_build):
        self.location_in_build = location_in_build
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.location_in_build is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='room_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('room_recordType')
        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_ == 'room_recordType':
            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_='room_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='room_recordType', 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_='room_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='room_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.location_in_build is not None:
            namespaceprefix_ = self.location_in_build_nsprefix_ + ':' if (UseCapturedNS_ and self.location_in_build_nsprefix_) else ''
            self.location_in_build.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location_in_build', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectCadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = ParamsRoomWithoutSpecialType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'location_in_build':
            obj_ = LocationInBuild.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.location_in_build = obj_
            obj_.original_tagname_ = 'location_in_build'
# end class room_recordType


class car_parking_space_recordType(GeneratedsSuper):
    """car_parking_space_recordType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    е
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    (
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    )
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    м
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    location_in_build -- Р
    а
    с
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    в
    п
    р
    е
    д
    е
    л
    а
    х
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    (
    п
    л
    а
    н
    ы
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, location_in_build=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.location_in_build = location_in_build
        self.location_in_build_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, car_parking_space_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if car_parking_space_recordType.subclass:
            return car_parking_space_recordType.subclass(*args_, **kwargs_)
        else:
            return car_parking_space_recordType(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_location_in_build(self):
        return self.location_in_build
    def set_location_in_build(self, location_in_build):
        self.location_in_build = location_in_build
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.location_in_build is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='car_parking_space_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('car_parking_space_recordType')
        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_ == 'car_parking_space_recordType':
            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_='car_parking_space_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='car_parking_space_recordType', 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_='car_parking_space_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='car_parking_space_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.location_in_build is not None:
            namespaceprefix_ = self.location_in_build_nsprefix_ + ':' if (UseCapturedNS_ and self.location_in_build_nsprefix_) else ''
            self.location_in_build.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location_in_build', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectCadNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = Area.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'location_in_build':
            obj_ = LevelAll.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.location_in_build = obj_
            obj_.original_tagname_ = 'location_in_build'
# end class car_parking_space_recordType


class land_recordsType(GeneratedsSuper):
    """land_recordsType -- З
    е
    м
    е
    л
    ь
    н
    ы
    е
    у
    ч
    а
    с
    т
    к
    и
    land_record -- З
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_record=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 land_record is None:
            self.land_record = []
        else:
            self.land_record = land_record
        self.land_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, land_recordsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if land_recordsType.subclass:
            return land_recordsType.subclass(*args_, **kwargs_)
        else:
            return land_recordsType(*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_land_record(self):
        return self.land_record
    def set_land_record(self, land_record):
        self.land_record = land_record
    def add_land_record(self, value):
        self.land_record.append(value)
    def insert_land_record_at(self, index, value):
        self.land_record.insert(index, value)
    def replace_land_record_at(self, index, value):
        self.land_record[index] = value
    def has__content(self):
        if (
            self.land_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='land_recordsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('land_recordsType')
        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_ == 'land_recordsType':
            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_='land_recordsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='land_recordsType', 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_='land_recordsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='land_recordsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for land_record_ in self.land_record:
            namespaceprefix_ = self.land_record_nsprefix_ + ':' if (UseCapturedNS_ and self.land_record_nsprefix_) else ''
            land_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_record':
            obj_ = LandRecord.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_record.append(obj_)
            obj_.original_tagname_ = 'land_record'
# end class land_recordsType


class room_recordsType(GeneratedsSuper):
    """room_recordsType -- П
    о
    м
    е
    щ
    е
    н
    и
    я
    room_record -- П
    о
    м
    е
    щ
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, room_record=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 room_record is None:
            self.room_record = []
        else:
            self.room_record = room_record
        self.room_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, room_recordsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if room_recordsType.subclass:
            return room_recordsType.subclass(*args_, **kwargs_)
        else:
            return room_recordsType(*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_room_record(self):
        return self.room_record
    def set_room_record(self, room_record):
        self.room_record = room_record
    def add_room_record(self, value):
        self.room_record.append(value)
    def insert_room_record_at(self, index, value):
        self.room_record.insert(index, value)
    def replace_room_record_at(self, index, value):
        self.room_record[index] = value
    def has__content(self):
        if (
            self.room_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='room_recordsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('room_recordsType')
        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_ == 'room_recordsType':
            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_='room_recordsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='room_recordsType', 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_='room_recordsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='room_recordsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for room_record_ in self.room_record:
            namespaceprefix_ = self.room_record_nsprefix_ + ':' if (UseCapturedNS_ and self.room_record_nsprefix_) else ''
            room_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='room_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'room_record':
            obj_ = RoomRecord.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.room_record.append(obj_)
            obj_.original_tagname_ = 'room_record'
# end class room_recordsType


class car_parking_space_recordsType(GeneratedsSuper):
    """car_parking_space_recordsType -- М
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    а
    car_parking_space_record -- М
    а
    ш
    и
    н
    о
    -
    м
    е
    с
    т
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, car_parking_space_record=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 car_parking_space_record is None:
            self.car_parking_space_record = []
        else:
            self.car_parking_space_record = car_parking_space_record
        self.car_parking_space_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, car_parking_space_recordsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if car_parking_space_recordsType.subclass:
            return car_parking_space_recordsType.subclass(*args_, **kwargs_)
        else:
            return car_parking_space_recordsType(*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_car_parking_space_record(self):
        return self.car_parking_space_record
    def set_car_parking_space_record(self, car_parking_space_record):
        self.car_parking_space_record = car_parking_space_record
    def add_car_parking_space_record(self, value):
        self.car_parking_space_record.append(value)
    def insert_car_parking_space_record_at(self, index, value):
        self.car_parking_space_record.insert(index, value)
    def replace_car_parking_space_record_at(self, index, value):
        self.car_parking_space_record[index] = value
    def has__content(self):
        if (
            self.car_parking_space_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='car_parking_space_recordsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('car_parking_space_recordsType')
        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_ == 'car_parking_space_recordsType':
            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_='car_parking_space_recordsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='car_parking_space_recordsType', 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_='car_parking_space_recordsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='car_parking_space_recordsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for car_parking_space_record_ in self.car_parking_space_record:
            namespaceprefix_ = self.car_parking_space_record_nsprefix_ + ':' if (UseCapturedNS_ and self.car_parking_space_record_nsprefix_) else ''
            car_parking_space_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='car_parking_space_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'car_parking_space_record':
            obj_ = CarParkingSpaceRecord.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.car_parking_space_record.append(obj_)
            obj_.original_tagname_ = 'car_parking_space_record'
# end class car_parking_space_recordsType


class property_complex_recordsType(GeneratedsSuper):
    """property_complex_recordsType -- П
    р
    е
    д
    п
    р
    и
    я
    т
    и
    я
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    ы
    е
    к
    о
    м
    п
    л
    е
    к
    с
    ы
    property_complex_record -- П
    р
    е
    д
    п
    р
    и
    я
    т
    и
    е
    к
    а
    к
    и
    м
    у
    щ
    е
    с
    т
    в
    е
    н
    н
    ы
    й
    к
    о
    м
    п
    л
    е
    к
    с
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, property_complex_record=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 property_complex_record is None:
            self.property_complex_record = []
        else:
            self.property_complex_record = property_complex_record
        self.property_complex_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, property_complex_recordsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if property_complex_recordsType.subclass:
            return property_complex_recordsType.subclass(*args_, **kwargs_)
        else:
            return property_complex_recordsType(*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_property_complex_record(self):
        return self.property_complex_record
    def set_property_complex_record(self, property_complex_record):
        self.property_complex_record = property_complex_record
    def add_property_complex_record(self, value):
        self.property_complex_record.append(value)
    def insert_property_complex_record_at(self, index, value):
        self.property_complex_record.insert(index, value)
    def replace_property_complex_record_at(self, index, value):
        self.property_complex_record[index] = value
    def has__content(self):
        if (
            self.property_complex_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='property_complex_recordsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('property_complex_recordsType')
        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_ == 'property_complex_recordsType':
            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_='property_complex_recordsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='property_complex_recordsType', 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_='property_complex_recordsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='property_complex_recordsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for property_complex_record_ in self.property_complex_record:
            namespaceprefix_ = self.property_complex_record_nsprefix_ + ':' if (UseCapturedNS_ and self.property_complex_record_nsprefix_) else ''
            property_complex_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='property_complex_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'property_complex_record':
            obj_ = PropertyComplexRecord.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.property_complex_record.append(obj_)
            obj_.original_tagname_ = 'property_complex_record'
# end class property_complex_recordsType


class unified_real_estate_complex_recordsType(GeneratedsSuper):
    """unified_real_estate_complex_recordsType -- Е
    д
    и
    н
    ы
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    ы
    е
    к
    о
    м
    п
    л
    е
    к
    с
    ы
    unified_real_estate_complex_record -- Е
    д
    и
    н
    ы
    й
    н
    е
    д
    в
    и
    ж
    и
    м
    ы
    й
    к
    о
    м
    п
    л
    е
    к
    с
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, unified_real_estate_complex_record=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 unified_real_estate_complex_record is None:
            self.unified_real_estate_complex_record = []
        else:
            self.unified_real_estate_complex_record = unified_real_estate_complex_record
        self.unified_real_estate_complex_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, unified_real_estate_complex_recordsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if unified_real_estate_complex_recordsType.subclass:
            return unified_real_estate_complex_recordsType.subclass(*args_, **kwargs_)
        else:
            return unified_real_estate_complex_recordsType(*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_unified_real_estate_complex_record(self):
        return self.unified_real_estate_complex_record
    def set_unified_real_estate_complex_record(self, unified_real_estate_complex_record):
        self.unified_real_estate_complex_record = unified_real_estate_complex_record
    def add_unified_real_estate_complex_record(self, value):
        self.unified_real_estate_complex_record.append(value)
    def insert_unified_real_estate_complex_record_at(self, index, value):
        self.unified_real_estate_complex_record.insert(index, value)
    def replace_unified_real_estate_complex_record_at(self, index, value):
        self.unified_real_estate_complex_record[index] = value
    def has__content(self):
        if (
            self.unified_real_estate_complex_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='unified_real_estate_complex_recordsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('unified_real_estate_complex_recordsType')
        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_ == 'unified_real_estate_complex_recordsType':
            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_='unified_real_estate_complex_recordsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='unified_real_estate_complex_recordsType', 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_='unified_real_estate_complex_recordsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='unified_real_estate_complex_recordsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for unified_real_estate_complex_record_ in self.unified_real_estate_complex_record:
            namespaceprefix_ = self.unified_real_estate_complex_record_nsprefix_ + ':' if (UseCapturedNS_ and self.unified_real_estate_complex_record_nsprefix_) else ''
            unified_real_estate_complex_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='unified_real_estate_complex_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'unified_real_estate_complex_record':
            obj_ = UnifiedRealEstateComplexRecord.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.unified_real_estate_complex_record.append(obj_)
            obj_.original_tagname_ = 'unified_real_estate_complex_record'
# end class unified_real_estate_complex_recordsType


class object_under_construction_recordsType(GeneratedsSuper):
    """object_under_construction_recordsType -- О
    б
    ъ
    е
    к
    т
    ы
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    object_under_construction_record -- О
    б
    ъ
    е
    к
    т
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object_under_construction_record=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 object_under_construction_record is None:
            self.object_under_construction_record = []
        else:
            self.object_under_construction_record = object_under_construction_record
        self.object_under_construction_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, object_under_construction_recordsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if object_under_construction_recordsType.subclass:
            return object_under_construction_recordsType.subclass(*args_, **kwargs_)
        else:
            return object_under_construction_recordsType(*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_object_under_construction_record(self):
        return self.object_under_construction_record
    def set_object_under_construction_record(self, object_under_construction_record):
        self.object_under_construction_record = object_under_construction_record
    def add_object_under_construction_record(self, value):
        self.object_under_construction_record.append(value)
    def insert_object_under_construction_record_at(self, index, value):
        self.object_under_construction_record.insert(index, value)
    def replace_object_under_construction_record_at(self, index, value):
        self.object_under_construction_record[index] = value
    def has__content(self):
        if (
            self.object_under_construction_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='object_under_construction_recordsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('object_under_construction_recordsType')
        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_ == 'object_under_construction_recordsType':
            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_='object_under_construction_recordsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='object_under_construction_recordsType', 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_='object_under_construction_recordsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='object_under_construction_recordsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for object_under_construction_record_ in self.object_under_construction_record:
            namespaceprefix_ = self.object_under_construction_record_nsprefix_ + ':' if (UseCapturedNS_ and self.object_under_construction_record_nsprefix_) else ''
            object_under_construction_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_under_construction_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object_under_construction_record':
            obj_ = ObjectUnderConstructionRecord.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_under_construction_record.append(obj_)
            obj_.original_tagname_ = 'object_under_construction_record'
# end class object_under_construction_recordsType


class build_recordsType(GeneratedsSuper):
    """build_recordsType -- З
    д
    а
    н
    и
    я
    build_record -- З
    д
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, build_record=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 build_record is None:
            self.build_record = []
        else:
            self.build_record = build_record
        self.build_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, build_recordsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if build_recordsType.subclass:
            return build_recordsType.subclass(*args_, **kwargs_)
        else:
            return build_recordsType(*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_build_record(self):
        return self.build_record
    def set_build_record(self, build_record):
        self.build_record = build_record
    def add_build_record(self, value):
        self.build_record.append(value)
    def insert_build_record_at(self, index, value):
        self.build_record.insert(index, value)
    def replace_build_record_at(self, index, value):
        self.build_record[index] = value
    def has__content(self):
        if (
            self.build_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='build_recordsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('build_recordsType')
        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_ == 'build_recordsType':
            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_='build_recordsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='build_recordsType', 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_='build_recordsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='build_recordsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for build_record_ in self.build_record:
            namespaceprefix_ = self.build_record_nsprefix_ + ':' if (UseCapturedNS_ and self.build_record_nsprefix_) else ''
            build_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='build_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'build_record':
            obj_ = BuildRecord.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.build_record.append(obj_)
            obj_.original_tagname_ = 'build_record'
# end class build_recordsType


class construction_recordsType(GeneratedsSuper):
    """construction_recordsType -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    construction_record -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, construction_record=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 construction_record is None:
            self.construction_record = []
        else:
            self.construction_record = construction_record
        self.construction_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, construction_recordsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if construction_recordsType.subclass:
            return construction_recordsType.subclass(*args_, **kwargs_)
        else:
            return construction_recordsType(*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_construction_record(self):
        return self.construction_record
    def set_construction_record(self, construction_record):
        self.construction_record = construction_record
    def add_construction_record(self, value):
        self.construction_record.append(value)
    def insert_construction_record_at(self, index, value):
        self.construction_record.insert(index, value)
    def replace_construction_record_at(self, index, value):
        self.construction_record[index] = value
    def has__content(self):
        if (
            self.construction_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='construction_recordsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('construction_recordsType')
        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_ == 'construction_recordsType':
            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_='construction_recordsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='construction_recordsType', 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_='construction_recordsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='construction_recordsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for construction_record_ in self.construction_record:
            namespaceprefix_ = self.construction_record_nsprefix_ + ':' if (UseCapturedNS_ and self.construction_record_nsprefix_) else ''
            construction_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='construction_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'construction_record':
            obj_ = ConstructionRecord.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.construction_record.append(obj_)
            obj_.original_tagname_ = 'construction_record'
# end class construction_recordsType


class common_land_partsType(GeneratedsSuper):
    """common_land_partsType -- С
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    included_cad_numbers -- К
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    е
    н
    о
    м
    е
    р
    а
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    о
    в
    ,
    в
    х
    о
    д
    я
    щ
    и
    х
    в
    с
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    з
    е
    м
    л
    е
    п
    о
    л
    ь
    з
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, included_cad_numbers=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.included_cad_numbers = included_cad_numbers
        self.included_cad_numbers_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, common_land_partsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if common_land_partsType.subclass:
            return common_land_partsType.subclass(*args_, **kwargs_)
        else:
            return common_land_partsType(*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_included_cad_numbers(self):
        return self.included_cad_numbers
    def set_included_cad_numbers(self, included_cad_numbers):
        self.included_cad_numbers = included_cad_numbers
    def has__content(self):
        if (
            self.included_cad_numbers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='common_land_partsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('common_land_partsType')
        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_ == 'common_land_partsType':
            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_='common_land_partsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='common_land_partsType', 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_='common_land_partsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='common_land_partsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.included_cad_numbers is not None:
            namespaceprefix_ = self.included_cad_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.included_cad_numbers_nsprefix_) else ''
            self.included_cad_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='included_cad_numbers', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'included_cad_numbers':
            obj_ = IncludedCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.included_cad_numbers = obj_
            obj_.original_tagname_ = 'included_cad_numbers'
# end class common_land_partsType


class object_partType(GeneratedsSuper):
    """object_partType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    ч
    а
    с
    т
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    part_number -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    area -- П
    л
    о
    щ
    а
    д
    ь
    в
    к
    в
    а
    д
    р
    а
    т
    н
    ы
    х
    м
    е
    т
    р
    а
    х
    с
    о
    к
    р
    у
    г
    л
    е
    н
    и
    е
    м
    д
    о
    0,1
    к
    в
    а
    д
    р
    а
    т
    н
    о
    г
    о
    м
    е
    т
    р
    а
    content_restrictions -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    й
    footnote -- П
    р
    и
    м
    е
    ч
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, part_number=None, area=None, content_restrictions=None, footnote=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.part_number = part_number
        self.part_number_nsprefix_ = None
        self.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.content_restrictions = content_restrictions
        self.content_restrictions_nsprefix_ = None
        self.footnote = footnote
        self.footnote_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, object_partType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if object_partType.subclass:
            return object_partType.subclass(*args_, **kwargs_)
        else:
            return object_partType(*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_part_number(self):
        return self.part_number
    def set_part_number(self, part_number):
        self.part_number = part_number
    def get_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_content_restrictions(self):
        return self.content_restrictions
    def set_content_restrictions(self, content_restrictions):
        self.content_restrictions = content_restrictions
    def get_footnote(self):
        return self.footnote
    def set_footnote(self, footnote):
        self.footnote = footnote
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.part_number is not None or
            self.area is not None or
            self.content_restrictions is not None or
            self.footnote is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='object_partType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('object_partType')
        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_ == 'object_partType':
            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_='object_partType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='object_partType', 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_='object_partType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='object_partType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.part_number is not None:
            namespaceprefix_ = self.part_number_nsprefix_ + ':' if (UseCapturedNS_ and self.part_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spart_number>%s</%spart_number>%s' % (namespaceprefix_ , self.gds_format_integer(self.part_number, input_name='part_number'), namespaceprefix_ , eol_))
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.content_restrictions is not None:
            namespaceprefix_ = self.content_restrictions_nsprefix_ + ':' if (UseCapturedNS_ and self.content_restrictions_nsprefix_) else ''
            self.content_restrictions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='content_restrictions', pretty_print=pretty_print)
        if self.footnote is not None:
            namespaceprefix_ = self.footnote_nsprefix_ + ':' if (UseCapturedNS_ and self.footnote_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfootnote>%s</%sfootnote>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.footnote), input_name='footnote')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'part_number' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'part_number')
            ival_ = self.gds_validate_integer(ival_, node, 'part_number')
            self.part_number = ival_
            self.part_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'content_restrictions':
            obj_ = ContentRestrictions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.content_restrictions = obj_
            obj_.original_tagname_ = 'content_restrictions'
        elif nodeName_ == 'footnote':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'footnote')
            value_ = self.gds_validate_string(value_, node, 'footnote')
            self.footnote = value_
            self.footnote_nsprefix_ = child_.prefix
# end class object_partType


class actType(GeneratedsSuper):
    """actType -- А
    к
    т
    о
    п
    р
    е
    д
    о
    с
    т
    а
    в
    л
    е
    н
    и
    и
    underlying_doc -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, underlying_doc=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.underlying_doc = underlying_doc
        self.underlying_doc_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, actType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if actType.subclass:
            return actType.subclass(*args_, **kwargs_)
        else:
            return actType(*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_underlying_doc(self):
        return self.underlying_doc
    def set_underlying_doc(self, underlying_doc):
        self.underlying_doc = underlying_doc
    def has__content(self):
        if (
            self.underlying_doc is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='actType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('actType')
        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_ == 'actType':
            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_='actType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='actType', 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_='actType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='actType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.underlying_doc is not None:
            namespaceprefix_ = self.underlying_doc_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_doc_nsprefix_) else ''
            self.underlying_doc.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_doc', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'underlying_doc':
            obj_ = DocRequisiteMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_doc = obj_
            obj_.original_tagname_ = 'underlying_doc'
# end class actType


class decision_ownerType(GeneratedsSuper):
    """decision_ownerType -- Р
    е
    ш
    е
    н
    и
    е
    с
    о
    б
    с
    т
    в
    е
    н
    н
    и
    к
    а
    underlying_docs -- Д
    о
    к
    у
    м
    е
    н
    т
    -
    о
    с
    н
    о
    в
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, underlying_docs=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.underlying_docs = underlying_docs
        self.underlying_docs_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, decision_ownerType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if decision_ownerType.subclass:
            return decision_ownerType.subclass(*args_, **kwargs_)
        else:
            return decision_ownerType(*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_underlying_docs(self):
        return self.underlying_docs
    def set_underlying_docs(self, underlying_docs):
        self.underlying_docs = underlying_docs
    def has__content(self):
        if (
            self.underlying_docs is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='decision_ownerType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('decision_ownerType')
        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_ == 'decision_ownerType':
            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_='decision_ownerType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='decision_ownerType', 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_='decision_ownerType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='decision_ownerType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.underlying_docs is not None:
            namespaceprefix_ = self.underlying_docs_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_docs_nsprefix_) else ''
            self.underlying_docs.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_docs', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'underlying_docs':
            obj_ = DocRequisiteMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_docs = obj_
            obj_.original_tagname_ = 'underlying_docs'
# end class decision_ownerType


class forestType(GeneratedsSuper):
    """forestType -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    а
    л
    е
    с
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
      
    * forestry -- Н
      а
      и
      м
      е
      н
      о
      в
      а
      н
      и
      е
      л
      е
      с
      н
      и
      ч
      е
      с
      т
      в
      а
      ,
      л
      е
      с
      о
      п
      а
      р
      к
      а
      ,
      у
      ч
      а
      с
      т
      к
      о
      в
      о
      г
      о
      л
      е
      с
      н
      и
      ч
      е
      с
      т
      в
      а
    * forest_quarters -- Н
      о
      м
      е
      р
      а
      л
      е
      с
      н
      ы
      х
      к
      в
      а
      р
      т
      а
      л
      о
      в
    * forest_purpose -- Ц
      е
      л
      е
      в
      о
      е
      н
      а
      з
      н
      а
      ч
      е
      н
      и
      е
      (
      к
      а
      т
      е
      г
      о
      р
      и
      я
      )
      л
      е
      с
      о
      в
    * forest_category -- К
      а
      т
      е
      г
      о
      р
      и
      я
      з
      а
      щ
      и
      т
      н
      ы
      х
      л
      е
      с
      о
      в
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, forestry=None, forest_quarters=None, forest_purpose=None, forest_category=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.forestry = forestry
        self.forestry_nsprefix_ = None
        self.forest_quarters = forest_quarters
        self.forest_quarters_nsprefix_ = None
        self.forest_purpose = forest_purpose
        self.forest_purpose_nsprefix_ = None
        self.forest_category = forest_category
        self.forest_category_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, forestType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if forestType.subclass:
            return forestType.subclass(*args_, **kwargs_)
        else:
            return forestType(*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_forestry(self):
        return self.forestry
    def set_forestry(self, forestry):
        self.forestry = forestry
    def get_forest_quarters(self):
        return self.forest_quarters
    def set_forest_quarters(self, forest_quarters):
        self.forest_quarters = forest_quarters
    def get_forest_purpose(self):
        return self.forest_purpose
    def set_forest_purpose(self, forest_purpose):
        self.forest_purpose = forest_purpose
    def get_forest_category(self):
        return self.forest_category
    def set_forest_category(self, forest_category):
        self.forest_category = forest_category
    def has__content(self):
        if (
            self.forestry is not None or
            self.forest_quarters is not None or
            self.forest_purpose is not None or
            self.forest_category is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='forestType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('forestType')
        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_ == 'forestType':
            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_='forestType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='forestType', 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_='forestType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='forestType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.forestry is not None:
            namespaceprefix_ = self.forestry_nsprefix_ + ':' if (UseCapturedNS_ and self.forestry_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sforestry>%s</%sforestry>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.forestry), input_name='forestry')), namespaceprefix_ , eol_))
        if self.forest_quarters is not None:
            namespaceprefix_ = self.forest_quarters_nsprefix_ + ':' if (UseCapturedNS_ and self.forest_quarters_nsprefix_) else ''
            self.forest_quarters.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forest_quarters', pretty_print=pretty_print)
        if self.forest_purpose is not None:
            namespaceprefix_ = self.forest_purpose_nsprefix_ + ':' if (UseCapturedNS_ and self.forest_purpose_nsprefix_) else ''
            self.forest_purpose.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forest_purpose', pretty_print=pretty_print)
        if self.forest_category is not None:
            namespaceprefix_ = self.forest_category_nsprefix_ + ':' if (UseCapturedNS_ and self.forest_category_nsprefix_) else ''
            self.forest_category.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forest_category', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'forestry':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'forestry')
            value_ = self.gds_validate_string(value_, node, 'forestry')
            self.forestry = value_
            self.forestry_nsprefix_ = child_.prefix
        elif nodeName_ == 'forest_quarters':
            obj_ = ForestQuarters.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forest_quarters = obj_
            obj_.original_tagname_ = 'forest_quarters'
        elif nodeName_ == 'forest_purpose':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forest_purpose = obj_
            obj_.original_tagname_ = 'forest_purpose'
        elif nodeName_ == 'forest_category':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forest_category = obj_
            obj_.original_tagname_ = 'forest_category'
# end class forestType


class forest_quartersType(GeneratedsSuper):
    """forest_quartersType -- Н
    о
    м
    е
    р
    а
    л
    е
    с
    н
    ы
    х
    к
    в
    а
    р
    т
    а
    л
    о
    в
    forest_quarter -- Н
    о
    м
    е
    р
    л
    е
    с
    н
    о
    г
    о
    к
    в
    а
    р
    т
    а
    л
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, forest_quarter=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 forest_quarter is None:
            self.forest_quarter = []
        else:
            self.forest_quarter = forest_quarter
        self.forest_quarter_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, forest_quartersType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if forest_quartersType.subclass:
            return forest_quartersType.subclass(*args_, **kwargs_)
        else:
            return forest_quartersType(*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_forest_quarter(self):
        return self.forest_quarter
    def set_forest_quarter(self, forest_quarter):
        self.forest_quarter = forest_quarter
    def add_forest_quarter(self, value):
        self.forest_quarter.append(value)
    def insert_forest_quarter_at(self, index, value):
        self.forest_quarter.insert(index, value)
    def replace_forest_quarter_at(self, index, value):
        self.forest_quarter[index] = value
    def has__content(self):
        if (
            self.forest_quarter
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='forest_quartersType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('forest_quartersType')
        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_ == 'forest_quartersType':
            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_='forest_quartersType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='forest_quartersType', 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_='forest_quartersType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='forest_quartersType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for forest_quarter_ in self.forest_quarter:
            namespaceprefix_ = self.forest_quarter_nsprefix_ + ':' if (UseCapturedNS_ and self.forest_quarter_nsprefix_) else ''
            forest_quarter_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forest_quarter', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'forest_quarter':
            obj_ = ForestQuarter.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forest_quarter.append(obj_)
            obj_.original_tagname_ = 'forest_quarter'
# end class forest_quartersType


class right_recordType(GeneratedsSuper):
    """right_recordType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    record_info -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    right_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    right_holders -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    underlying_documents -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    third_party_consents -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    е
    н
    и
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    с
    д
    е
    л
    к
    и
    ,
    п
    р
    а
    в
    а
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    ,
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    ы
    х
    б
    е
    з
    н
    е
    о
    б
    х
    о
    д
    и
    м
    о
    г
    о
    в
    с
    и
    л
    у
    з
    а
    к
    о
    н
    а
    с
    о
    г
    л
    а
    с
    и
    я
    т
    р
    е
    т
    ь
    е
    г
    о
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, right_data=None, right_holders=None, underlying_documents=None, third_party_consents=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.right_data = right_data
        self.right_data_nsprefix_ = None
        self.right_holders = right_holders
        self.right_holders_nsprefix_ = None
        self.underlying_documents = underlying_documents
        self.underlying_documents_nsprefix_ = None
        self.third_party_consents = third_party_consents
        self.third_party_consents_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, right_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if right_recordType.subclass:
            return right_recordType.subclass(*args_, **kwargs_)
        else:
            return right_recordType(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_right_data(self):
        return self.right_data
    def set_right_data(self, right_data):
        self.right_data = right_data
    def get_right_holders(self):
        return self.right_holders
    def set_right_holders(self, right_holders):
        self.right_holders = right_holders
    def get_underlying_documents(self):
        return self.underlying_documents
    def set_underlying_documents(self, underlying_documents):
        self.underlying_documents = underlying_documents
    def get_third_party_consents(self):
        return self.third_party_consents
    def set_third_party_consents(self, third_party_consents):
        self.third_party_consents = third_party_consents
    def has__content(self):
        if (
            self.record_info is not None or
            self.right_data is not None or
            self.right_holders is not None or
            self.underlying_documents is not None or
            self.third_party_consents is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('right_recordType')
        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_ == 'right_recordType':
            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_='right_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='right_recordType', 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_='right_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.right_data is not None:
            namespaceprefix_ = self.right_data_nsprefix_ + ':' if (UseCapturedNS_ and self.right_data_nsprefix_) else ''
            self.right_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_data', pretty_print=pretty_print)
        if self.right_holders is not None:
            namespaceprefix_ = self.right_holders_nsprefix_ + ':' if (UseCapturedNS_ and self.right_holders_nsprefix_) else ''
            self.right_holders.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_holders', pretty_print=pretty_print)
        if self.underlying_documents is not None:
            namespaceprefix_ = self.underlying_documents_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_documents_nsprefix_) else ''
            self.underlying_documents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_documents', pretty_print=pretty_print)
        if self.third_party_consents is not None:
            namespaceprefix_ = self.third_party_consents_nsprefix_ + ':' if (UseCapturedNS_ and self.third_party_consents_nsprefix_) else ''
            self.third_party_consents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='third_party_consents', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RegistrationDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'right_data':
            obj_ = RightDataReinstatement.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_data = obj_
            obj_.original_tagname_ = 'right_data'
        elif nodeName_ == 'right_holders':
            obj_ = RightHoldersOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_holders = obj_
            obj_.original_tagname_ = 'right_holders'
        elif nodeName_ == 'underlying_documents':
            obj_ = UnderlyingDocumentsOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_documents = obj_
            obj_.original_tagname_ = 'underlying_documents'
        elif nodeName_ == 'third_party_consents':
            obj_ = ThirdPartyConsents.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.third_party_consents = obj_
            obj_.original_tagname_ = 'third_party_consents'
# end class right_recordType


class right_recordType3(GeneratedsSuper):
    """right_recordType3 -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    record_info -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    right_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    right_holders -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    litigations -- З
    а
    я
    в
    л
    е
    н
    н
    ы
    е
    в
    с
    у
    д
    е
    б
    н
    о
    м
    п
    о
    р
    я
    д
    к
    е
    п
    р
    а
    в
    а
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    (
    н
    а
    л
    и
    ч
    и
    е
    с
    у
    д
    е
    б
    н
    о
    г
    о
    с
    п
    о
    р
    а
    )
    objections -- С
    в
    е
    д
    е
    н
    и
    я
    о
    в
    о
    з
    р
    а
    ж
    е
    н
    и
    и
    в
    о
    т
    н
    о
    ш
    е
    н
    и
    и
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    п
    р
    а
    в
    а
    personal_participations -- Л
    и
    ч
    н
    о
    е
    у
    ч
    а
    с
    т
    и
    е
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    third_party_consents -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    с
    у
    щ
    е
    с
    т
    в
    л
    е
    н
    и
    и
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    с
    д
    е
    л
    к
    и
    ,
    п
    р
    а
    в
    а
    ,
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    ,
    с
    о
    в
    е
    р
    ш
    е
    н
    н
    ы
    х
    б
    е
    з
    н
    е
    о
    б
    х
    о
    д
    и
    м
    о
    г
    о
    в
    с
    и
    л
    у
    з
    а
    к
    о
    н
    а
    с
    о
    г
    л
    а
    с
    и
    я
    т
    р
    е
    т
    ь
    е
    г
    о
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, right_data=None, right_holders=None, litigations=None, objections=None, personal_participations=None, third_party_consents=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.right_data = right_data
        self.right_data_nsprefix_ = None
        self.right_holders = right_holders
        self.right_holders_nsprefix_ = None
        self.litigations = litigations
        self.litigations_nsprefix_ = None
        self.objections = objections
        self.objections_nsprefix_ = None
        self.personal_participations = personal_participations
        self.personal_participations_nsprefix_ = None
        self.third_party_consents = third_party_consents
        self.third_party_consents_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, right_recordType3)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if right_recordType3.subclass:
            return right_recordType3.subclass(*args_, **kwargs_)
        else:
            return right_recordType3(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_right_data(self):
        return self.right_data
    def set_right_data(self, right_data):
        self.right_data = right_data
    def get_right_holders(self):
        return self.right_holders
    def set_right_holders(self, right_holders):
        self.right_holders = right_holders
    def get_litigations(self):
        return self.litigations
    def set_litigations(self, litigations):
        self.litigations = litigations
    def get_objections(self):
        return self.objections
    def set_objections(self, objections):
        self.objections = objections
    def get_personal_participations(self):
        return self.personal_participations
    def set_personal_participations(self, personal_participations):
        self.personal_participations = personal_participations
    def get_third_party_consents(self):
        return self.third_party_consents
    def set_third_party_consents(self, third_party_consents):
        self.third_party_consents = third_party_consents
    def has__content(self):
        if (
            self.record_info is not None or
            self.right_data is not None or
            self.right_holders is not None or
            self.litigations is not None or
            self.objections is not None or
            self.personal_participations is not None or
            self.third_party_consents is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_recordType3', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('right_recordType3')
        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_ == 'right_recordType3':
            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_='right_recordType3')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='right_recordType3', 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_='right_recordType3'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_recordType3', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.right_data is not None:
            namespaceprefix_ = self.right_data_nsprefix_ + ':' if (UseCapturedNS_ and self.right_data_nsprefix_) else ''
            self.right_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_data', pretty_print=pretty_print)
        if self.right_holders is not None:
            namespaceprefix_ = self.right_holders_nsprefix_ + ':' if (UseCapturedNS_ and self.right_holders_nsprefix_) else ''
            self.right_holders.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_holders', pretty_print=pretty_print)
        if self.litigations is not None:
            namespaceprefix_ = self.litigations_nsprefix_ + ':' if (UseCapturedNS_ and self.litigations_nsprefix_) else ''
            self.litigations.export(outfile, level, namespaceprefix_, namespacedef_='', name_='litigations', pretty_print=pretty_print)
        if self.objections is not None:
            namespaceprefix_ = self.objections_nsprefix_ + ':' if (UseCapturedNS_ and self.objections_nsprefix_) else ''
            self.objections.export(outfile, level, namespaceprefix_, namespacedef_='', name_='objections', pretty_print=pretty_print)
        if self.personal_participations is not None:
            namespaceprefix_ = self.personal_participations_nsprefix_ + ':' if (UseCapturedNS_ and self.personal_participations_nsprefix_) else ''
            self.personal_participations.export(outfile, level, namespaceprefix_, namespacedef_='', name_='personal_participations', pretty_print=pretty_print)
        if self.third_party_consents is not None:
            namespaceprefix_ = self.third_party_consents_nsprefix_ + ':' if (UseCapturedNS_ and self.third_party_consents_nsprefix_) else ''
            self.third_party_consents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='third_party_consents', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RegistrationDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'right_data':
            obj_ = RightDataReinstatement.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_data = obj_
            obj_.original_tagname_ = 'right_data'
        elif nodeName_ == 'right_holders':
            obj_ = RightHoldersOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_holders = obj_
            obj_.original_tagname_ = 'right_holders'
        elif nodeName_ == 'litigations':
            obj_ = LitigationsContent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.litigations = obj_
            obj_.original_tagname_ = 'litigations'
        elif nodeName_ == 'objections':
            obj_ = Objections.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.objections = obj_
            obj_.original_tagname_ = 'objections'
        elif nodeName_ == 'personal_participations':
            obj_ = PersonalParticipations.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.personal_participations = obj_
            obj_.original_tagname_ = 'personal_participations'
        elif nodeName_ == 'third_party_consents':
            obj_ = ThirdPartyConsents.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.third_party_consents = obj_
            obj_.original_tagname_ = 'third_party_consents'
# end class right_recordType3


class right_recordType4(GeneratedsSuper):
    """right_recordType4 -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    record_info -- Д
    а
    т
    ы
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    right_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    right_holders -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    underlying_documents -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    changes -- И
    з
    м
    е
    н
    е
    н
    и
    е
    р
    е
    е
    с
    т
    р
    о
    в
    ы
    х
    з
    а
    п
    и
    с
    е
    й
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, right_data=None, right_holders=None, underlying_documents=None, changes=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.right_data = right_data
        self.right_data_nsprefix_ = None
        self.right_holders = right_holders
        self.right_holders_nsprefix_ = None
        self.underlying_documents = underlying_documents
        self.underlying_documents_nsprefix_ = None
        self.changes = changes
        self.changes_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, right_recordType4)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if right_recordType4.subclass:
            return right_recordType4.subclass(*args_, **kwargs_)
        else:
            return right_recordType4(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_right_data(self):
        return self.right_data
    def set_right_data(self, right_data):
        self.right_data = right_data
    def get_right_holders(self):
        return self.right_holders
    def set_right_holders(self, right_holders):
        self.right_holders = right_holders
    def get_underlying_documents(self):
        return self.underlying_documents
    def set_underlying_documents(self, underlying_documents):
        self.underlying_documents = underlying_documents
    def get_changes(self):
        return self.changes
    def set_changes(self, changes):
        self.changes = changes
    def has__content(self):
        if (
            self.record_info is not None or
            self.right_data is not None or
            self.right_holders is not None or
            self.underlying_documents is not None or
            self.changes is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_recordType4', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('right_recordType4')
        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_ == 'right_recordType4':
            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_='right_recordType4')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='right_recordType4', 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_='right_recordType4'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_recordType4', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.right_data is not None:
            namespaceprefix_ = self.right_data_nsprefix_ + ':' if (UseCapturedNS_ and self.right_data_nsprefix_) else ''
            self.right_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_data', pretty_print=pretty_print)
        if self.right_holders is not None:
            namespaceprefix_ = self.right_holders_nsprefix_ + ':' if (UseCapturedNS_ and self.right_holders_nsprefix_) else ''
            self.right_holders.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_holders', pretty_print=pretty_print)
        if self.underlying_documents is not None:
            namespaceprefix_ = self.underlying_documents_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_documents_nsprefix_) else ''
            self.underlying_documents.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_documents', pretty_print=pretty_print)
        if self.changes is not None:
            namespaceprefix_ = self.changes_nsprefix_ + ':' if (UseCapturedNS_ and self.changes_nsprefix_) else ''
            self.changes.export(outfile, level, namespaceprefix_, namespacedef_='', name_='changes', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RecordInfo.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'right_data':
            obj_ = RightDataAndCancel.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_data = obj_
            obj_.original_tagname_ = 'right_data'
        elif nodeName_ == 'right_holders':
            obj_ = RightHoldersOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_holders = obj_
            obj_.original_tagname_ = 'right_holders'
        elif nodeName_ == 'underlying_documents':
            obj_ = DocumentsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_documents = obj_
            obj_.original_tagname_ = 'underlying_documents'
        elif nodeName_ == 'changes':
            obj_ = Changes.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.changes = obj_
            obj_.original_tagname_ = 'changes'
# end class right_recordType4


class right_recordType5(GeneratedsSuper):
    """right_recordType5 -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    е
    и
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    record_info -- Д
    а
    т
    а
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    right_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    а
    х
    right_holders -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    х
    litigations -- З
    а
    я
    в
    л
    е
    н
    н
    ы
    е
    в
    с
    у
    д
    е
    б
    н
    о
    м
    п
    о
    р
    я
    д
    к
    е
    п
    р
    а
    в
    а
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    (
    н
    а
    л
    и
    ч
    и
    е
    с
    у
    д
    е
    б
    н
    о
    г
    о
    с
    п
    о
    р
    а
    )
    objections -- С
    в
    е
    д
    е
    н
    и
    я
    о
    в
    о
    з
    р
    а
    ж
    е
    н
    и
    и
    в
    о
    т
    н
    о
    ш
    е
    н
    и
    и
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, right_data=None, right_holders=None, litigations=None, objections=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.right_data = right_data
        self.right_data_nsprefix_ = None
        self.right_holders = right_holders
        self.right_holders_nsprefix_ = None
        self.litigations = litigations
        self.litigations_nsprefix_ = None
        self.objections = objections
        self.objections_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, right_recordType5)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if right_recordType5.subclass:
            return right_recordType5.subclass(*args_, **kwargs_)
        else:
            return right_recordType5(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_right_data(self):
        return self.right_data
    def set_right_data(self, right_data):
        self.right_data = right_data
    def get_right_holders(self):
        return self.right_holders
    def set_right_holders(self, right_holders):
        self.right_holders = right_holders
    def get_litigations(self):
        return self.litigations
    def set_litigations(self, litigations):
        self.litigations = litigations
    def get_objections(self):
        return self.objections
    def set_objections(self, objections):
        self.objections = objections
    def has__content(self):
        if (
            self.record_info is not None or
            self.right_data is not None or
            self.right_holders is not None or
            self.litigations is not None or
            self.objections is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_recordType5', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('right_recordType5')
        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_ == 'right_recordType5':
            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_='right_recordType5')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='right_recordType5', 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_='right_recordType5'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_recordType5', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.right_data is not None:
            namespaceprefix_ = self.right_data_nsprefix_ + ':' if (UseCapturedNS_ and self.right_data_nsprefix_) else ''
            self.right_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_data', pretty_print=pretty_print)
        if self.right_holders is not None:
            namespaceprefix_ = self.right_holders_nsprefix_ + ':' if (UseCapturedNS_ and self.right_holders_nsprefix_) else ''
            self.right_holders.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_holders', pretty_print=pretty_print)
        if self.litigations is not None:
            namespaceprefix_ = self.litigations_nsprefix_ + ':' if (UseCapturedNS_ and self.litigations_nsprefix_) else ''
            self.litigations.export(outfile, level, namespaceprefix_, namespacedef_='', name_='litigations', pretty_print=pretty_print)
        if self.objections is not None:
            namespaceprefix_ = self.objections_nsprefix_ + ':' if (UseCapturedNS_ and self.objections_nsprefix_) else ''
            self.objections.export(outfile, level, namespaceprefix_, namespacedef_='', name_='objections', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RegistrationDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'right_data':
            obj_ = RightDataReinstatement.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_data = obj_
            obj_.original_tagname_ = 'right_data'
        elif nodeName_ == 'right_holders':
            obj_ = RightHoldersOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_holders = obj_
            obj_.original_tagname_ = 'right_holders'
        elif nodeName_ == 'litigations':
            obj_ = LitigationsContent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.litigations = obj_
            obj_.original_tagname_ = 'litigations'
        elif nodeName_ == 'objections':
            obj_ = Objections.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.objections = obj_
            obj_.original_tagname_ = 'objections'
# end class right_recordType5


class personal_participationType(GeneratedsSuper):
    """personal_participationType -- Л
    и
    ч
    н
    о
    е
    у
    ч
    а
    с
    т
    и
    е
    п
    р
    а
    в
    о
    о
    б
    л
    а
    д
    а
    т
    е
    л
    я
    inability_info -- П
    р
    и
    н
    я
    т
    о
    з
    а
    я
    в
    л
    е
    н
    и
    е
    о
    н
    е
    в
    о
    з
    м
    о
    ж
    н
    о
    с
    т
    и
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    б
    е
    з
    л
    и
    ч
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, inability_info=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.inability_info = inability_info
        self.inability_info_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, personal_participationType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if personal_participationType.subclass:
            return personal_participationType.subclass(*args_, **kwargs_)
        else:
            return personal_participationType(*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_inability_info(self):
        return self.inability_info
    def set_inability_info(self, inability_info):
        self.inability_info = inability_info
    def has__content(self):
        if (
            self.inability_info is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='personal_participationType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('personal_participationType')
        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_ == 'personal_participationType':
            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_='personal_participationType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='personal_participationType', 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_='personal_participationType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='personal_participationType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.inability_info is not None:
            namespaceprefix_ = self.inability_info_nsprefix_ + ':' if (UseCapturedNS_ and self.inability_info_nsprefix_) else ''
            self.inability_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='inability_info', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'inability_info':
            obj_ = OriginContent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.inability_info = obj_
            obj_.original_tagname_ = 'inability_info'
# end class personal_participationType


class claim_recordType(GeneratedsSuper):
    """claim_recordType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    и
    claim_data -- П
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, claim_data=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.claim_data = claim_data
        self.claim_data_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, claim_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if claim_recordType.subclass:
            return claim_recordType.subclass(*args_, **kwargs_)
        else:
            return claim_recordType(*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_claim_data(self):
        return self.claim_data
    def set_claim_data(self, claim_data):
        self.claim_data = claim_data
    def has__content(self):
        if (
            self.claim_data is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='claim_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('claim_recordType')
        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_ == 'claim_recordType':
            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_='claim_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='claim_recordType', 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_='claim_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='claim_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.claim_data is not None:
            namespaceprefix_ = self.claim_data_nsprefix_ + ':' if (UseCapturedNS_ and self.claim_data_nsprefix_) else ''
            self.claim_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='claim_data', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'claim_data':
            obj_ = claim_dataType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.claim_data = obj_
            obj_.original_tagname_ = 'claim_data'
# end class claim_recordType


class claim_dataType(GeneratedsSuper):
    """claim_dataType -- П
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    е
      
    * urd_type -- В
      и
      д
      р
      е
      г
      и
      с
      т
      р
      а
      ц
      и
      о
      н
      н
      о
      -
      у
      ч
      е
      т
      н
      о
      г
      о
      д
      е
      й
      с
      т
      в
      и
      я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, urd_type=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.urd_type = urd_type
        self.urd_type_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, claim_dataType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if claim_dataType.subclass:
            return claim_dataType.subclass(*args_, **kwargs_)
        else:
            return claim_dataType(*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_urd_type(self):
        return self.urd_type
    def set_urd_type(self, urd_type):
        self.urd_type = urd_type
    def has__content(self):
        if (
            self.urd_type is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='claim_dataType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('claim_dataType')
        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_ == 'claim_dataType':
            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_='claim_dataType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='claim_dataType', 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_='claim_dataType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='claim_dataType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.urd_type is not None:
            namespaceprefix_ = self.urd_type_nsprefix_ + ':' if (UseCapturedNS_ and self.urd_type_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%surd_type>%s</%surd_type>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.urd_type), input_name='urd_type')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'urd_type':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'urd_type')
            value_ = self.gds_validate_string(value_, node, 'urd_type')
            self.urd_type = value_
            self.urd_type_nsprefix_ = child_.prefix
# end class claim_dataType


class claim_recordType6(GeneratedsSuper):
    """claim_recordType6 -- С
    в
    е
    д
    е
    н
    и
    я
    о
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    и
    claim_data -- П
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, claim_data=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.claim_data = claim_data
        self.claim_data_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, claim_recordType6)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if claim_recordType6.subclass:
            return claim_recordType6.subclass(*args_, **kwargs_)
        else:
            return claim_recordType6(*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_claim_data(self):
        return self.claim_data
    def set_claim_data(self, claim_data):
        self.claim_data = claim_data
    def has__content(self):
        if (
            self.claim_data is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='claim_recordType6', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('claim_recordType6')
        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_ == 'claim_recordType6':
            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_='claim_recordType6')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='claim_recordType6', 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_='claim_recordType6'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='claim_recordType6', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.claim_data is not None:
            namespaceprefix_ = self.claim_data_nsprefix_ + ':' if (UseCapturedNS_ and self.claim_data_nsprefix_) else ''
            self.claim_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='claim_data', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'claim_data':
            obj_ = ClaimDataOutAll.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.claim_data = obj_
            obj_.original_tagname_ = 'claim_data'
# end class claim_recordType6


class right_record_numbersType(GeneratedsSuper):
    """right_record_numbersType -- Н
    о
    м
    е
    р
    а
    р
    е
    е
    с
    т
    р
    о
    в
    ы
    х
    з
    а
    п
    и
    с
    е
    й
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    е
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    ы
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    я
    right_record_number -- Н
    о
    м
    е
    р
    р
    е
    е
    с
    т
    р
    о
    в
    о
    й
    з
    а
    п
    и
    с
    и
    ,
    н
    а
    к
    о
    т
    о
    р
    у
    ю
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    п
    р
    а
    в
    о
    п
    р
    и
    т
    я
    з
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_record_number=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 right_record_number is None:
            self.right_record_number = []
        else:
            self.right_record_number = right_record_number
        self.right_record_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, right_record_numbersType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if right_record_numbersType.subclass:
            return right_record_numbersType.subclass(*args_, **kwargs_)
        else:
            return right_record_numbersType(*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_right_record_number(self):
        return self.right_record_number
    def set_right_record_number(self, right_record_number):
        self.right_record_number = right_record_number
    def add_right_record_number(self, value):
        self.right_record_number.append(value)
    def insert_right_record_number_at(self, index, value):
        self.right_record_number.insert(index, value)
    def replace_right_record_number_at(self, index, value):
        self.right_record_number[index] = value
    def has__content(self):
        if (
            self.right_record_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_record_numbersType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('right_record_numbersType')
        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_ == 'right_record_numbersType':
            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_='right_record_numbersType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='right_record_numbersType', 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_='right_record_numbersType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_record_numbersType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for right_record_number_ in self.right_record_number:
            namespaceprefix_ = self.right_record_number_nsprefix_ + ':' if (UseCapturedNS_ and self.right_record_number_nsprefix_) else ''
            right_record_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_record_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_record_number':
            obj_ = RightRecordNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_record_number.append(obj_)
            obj_.original_tagname_ = 'right_record_number'
# end class right_record_numbersType


class objectionType(GeneratedsSuper):
    """objectionType -- В
    о
    з
    р
    а
    ж
    е
    н
    и
    е
    в
    о
    т
    н
    о
    ш
    е
    н
    и
    и
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    п
    р
    а
    в
    а
    objections_info -- П
    р
    и
    н
    я
    т
    о
    з
    а
    я
    в
    л
    е
    н
    и
    е
    о
    н
    а
    л
    и
    ч
    и
    и
    в
    о
    з
    р
    а
    ж
    е
    н
    и
    я
    в
    о
    т
    н
    о
    ш
    е
    н
    и
    и
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, objections_info=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.objections_info = objections_info
        self.objections_info_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, objectionType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if objectionType.subclass:
            return objectionType.subclass(*args_, **kwargs_)
        else:
            return objectionType(*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_objections_info(self):
        return self.objections_info
    def set_objections_info(self, objections_info):
        self.objections_info = objections_info
    def has__content(self):
        if (
            self.objections_info is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='objectionType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('objectionType')
        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_ == 'objectionType':
            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_='objectionType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='objectionType', 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_='objectionType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='objectionType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.objections_info is not None:
            namespaceprefix_ = self.objections_info_nsprefix_ + ':' if (UseCapturedNS_ and self.objections_info_nsprefix_) else ''
            self.objections_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='objections_info', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'objections_info':
            obj_ = OriginContent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.objections_info = obj_
            obj_.original_tagname_ = 'objections_info'
# end class objectionType


class litigationType(GeneratedsSuper):
    """litigationType -- Н
    а
    л
    и
    ч
    и
    е
    с
    у
    д
    е
    б
    н
    о
    г
    о
    с
    п
    о
    р
    а
    ligitation_info -- З
    а
    я
    в
    л
    е
    н
    о
    п
    р
    а
    в
    о
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, ligitation_info=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.ligitation_info = ligitation_info
        self.ligitation_info_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, litigationType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if litigationType.subclass:
            return litigationType.subclass(*args_, **kwargs_)
        else:
            return litigationType(*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_ligitation_info(self):
        return self.ligitation_info
    def set_ligitation_info(self, ligitation_info):
        self.ligitation_info = ligitation_info
    def has__content(self):
        if (
            self.ligitation_info is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='litigationType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('litigationType')
        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_ == 'litigationType':
            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_='litigationType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='litigationType', 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_='litigationType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='litigationType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ligitation_info is not None:
            namespaceprefix_ = self.ligitation_info_nsprefix_ + ':' if (UseCapturedNS_ and self.ligitation_info_nsprefix_) else ''
            self.ligitation_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ligitation_info', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ligitation_info':
            obj_ = ligitation_infoType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ligitation_info = obj_
            obj_.original_tagname_ = 'ligitation_info'
# end class litigationType


class ligitation_infoType(GeneratedsSuper):
    """ligitation_infoType -- З
    а
    я
    в
    л
    е
    н
    о
    п
    р
    а
    в
    о
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    decision_requisites -- Р
    е
    к
    в
    и
    з
    и
    т
    ы
    в
    с
    т
    у
    п
    и
    в
    ш
    е
    г
    о
    в
    з
    а
    к
    о
    н
    н
    у
    ю
    с
    и
    л
    у
    р
    е
    ш
    е
    н
    и
    я
    с
    у
    д
    а
    act_acceptance_timestamp -- Д
    а
    т
    а
    и
    в
    р
    е
    м
    я
    п
    р
    и
    е
    м
    а
    с
    у
    д
    е
    б
    н
    о
    г
    о
    а
    к
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, decision_requisites=None, act_acceptance_timestamp=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.decision_requisites = decision_requisites
        self.decision_requisites_nsprefix_ = None
        if isinstance(act_acceptance_timestamp, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(act_acceptance_timestamp, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = act_acceptance_timestamp
        self.act_acceptance_timestamp = initvalue_
        self.act_acceptance_timestamp_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ligitation_infoType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ligitation_infoType.subclass:
            return ligitation_infoType.subclass(*args_, **kwargs_)
        else:
            return ligitation_infoType(*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_decision_requisites(self):
        return self.decision_requisites
    def set_decision_requisites(self, decision_requisites):
        self.decision_requisites = decision_requisites
    def get_act_acceptance_timestamp(self):
        return self.act_acceptance_timestamp
    def set_act_acceptance_timestamp(self, act_acceptance_timestamp):
        self.act_acceptance_timestamp = act_acceptance_timestamp
    def has__content(self):
        if (
            self.decision_requisites is not None or
            self.act_acceptance_timestamp is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ligitation_infoType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ligitation_infoType')
        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_ == 'ligitation_infoType':
            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_='ligitation_infoType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ligitation_infoType', 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_='ligitation_infoType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ligitation_infoType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.decision_requisites is not None:
            namespaceprefix_ = self.decision_requisites_nsprefix_ + ':' if (UseCapturedNS_ and self.decision_requisites_nsprefix_) else ''
            self.decision_requisites.export(outfile, level, namespaceprefix_, namespacedef_='', name_='decision_requisites', pretty_print=pretty_print)
        if self.act_acceptance_timestamp is not None:
            namespaceprefix_ = self.act_acceptance_timestamp_nsprefix_ + ':' if (UseCapturedNS_ and self.act_acceptance_timestamp_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sact_acceptance_timestamp>%s</%sact_acceptance_timestamp>%s' % (namespaceprefix_ , self.gds_format_datetime(self.act_acceptance_timestamp, input_name='act_acceptance_timestamp'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'decision_requisites':
            obj_ = DocRequisiteMain.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.decision_requisites = obj_
            obj_.original_tagname_ = 'decision_requisites'
        elif nodeName_ == 'act_acceptance_timestamp':
            sval_ = child_.text
            dval_ = self.gds_parse_datetime(sval_)
            self.act_acceptance_timestamp = dval_
            self.act_acceptance_timestamp_nsprefix_ = child_.prefix
# end class ligitation_infoType


class litigationType7(GeneratedsSuper):
    """litigationType7 -- З
    а
    я
    в
    л
    е
    н
    н
    о
    е
    в
    с
    у
    д
    е
    б
    н
    о
    м
    п
    о
    р
    я
    д
    к
    е
    п
    р
    а
    в
    о
    т
    р
    е
    б
    о
    в
    а
    н
    и
    я
    mark_content -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    т
    м
    е
    т
    к
    и
    п
    р
    и
    в
    о
    з
    н
    и
    к
    н
    о
    в
    е
    н
    и
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark_content=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_content = mark_content
        self.mark_content_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, litigationType7)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if litigationType7.subclass:
            return litigationType7.subclass(*args_, **kwargs_)
        else:
            return litigationType7(*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_mark_content(self):
        return self.mark_content
    def set_mark_content(self, mark_content):
        self.mark_content = mark_content
    def has__content(self):
        if (
            self.mark_content is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='litigationType7', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('litigationType7')
        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_ == 'litigationType7':
            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_='litigationType7')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='litigationType7', 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_='litigationType7'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='litigationType7', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.mark_content is not None:
            namespaceprefix_ = self.mark_content_nsprefix_ + ':' if (UseCapturedNS_ and self.mark_content_nsprefix_) else ''
            self.mark_content.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mark_content', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'mark_content':
            obj_ = MarkContent.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.mark_content = obj_
            obj_.original_tagname_ = 'mark_content'
# end class litigationType7


class approve_personType(GeneratedsSuper):
    """approve_personType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    л
    и
    ц
    е
    ,
    у
    т
    в
    е
    р
    д
    и
    в
    ш
    е
    м
    п
    р
    о
    е
    к
    т
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    з
    е
    м
    е
    л
    ь
    н
    о
    г
    о
    у
    ч
    а
    с
    т
    к
    а
    individual -- Ф
    а
    м
    и
    л
    и
    я
    ,
    и
    м
    я
    ,
    о
    т
    ч
    е
    с
    т
    в
    о
    ф
    и
    з
    и
    ч
    е
    с
    к
    о
    г
    о
    л
    и
    ц
    а
    legal_entity -- П
    о
    л
    н
    о
    е
    н
    а
    и
    м
    е
    н
    о
    в
    а
    н
    и
    е
    ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    г
    о
    л
    и
    ц
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, individual=None, legal_entity=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.individual = individual
        self.individual_nsprefix_ = None
        self.legal_entity = legal_entity
        self.legal_entity_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, approve_personType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if approve_personType.subclass:
            return approve_personType.subclass(*args_, **kwargs_)
        else:
            return approve_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_individual(self):
        return self.individual
    def set_individual(self, individual):
        self.individual = individual
    def get_legal_entity(self):
        return self.legal_entity
    def set_legal_entity(self, legal_entity):
        self.legal_entity = legal_entity
    def has__content(self):
        if (
            self.individual is not None or
            self.legal_entity is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='approve_personType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('approve_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_ == 'approve_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_='approve_personType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='approve_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_='approve_personType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='approve_personType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.individual is not None:
            namespaceprefix_ = self.individual_nsprefix_ + ':' if (UseCapturedNS_ and self.individual_nsprefix_) else ''
            self.individual.export(outfile, level, namespaceprefix_, namespacedef_='', name_='individual', pretty_print=pretty_print)
        if self.legal_entity is not None:
            namespaceprefix_ = self.legal_entity_nsprefix_ + ':' if (UseCapturedNS_ and self.legal_entity_nsprefix_) else ''
            self.legal_entity.export(outfile, level, namespaceprefix_, namespacedef_='', name_='legal_entity', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'individual':
            obj_ = Fio.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.individual = obj_
            obj_.original_tagname_ = 'individual'
        elif nodeName_ == 'legal_entity':
            obj_ = Name.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.legal_entity = obj_
            obj_.original_tagname_ = 'legal_entity'
# end class approve_personType


class dissenting_entityType(GeneratedsSuper):
    """dissenting_entityType -- Н
    е
    п
    р
    е
    д
    с
    т
    а
    в
    л
    е
    н
    о
    с
    о
    г
    л
    а
    с
    и
    е
    л
    и
    ц
    а
    ,
    о
    р
    г
    а
    н
    а
    individual -- Ф
    и
    з
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    legal_entity -- Ю
    р
    и
    д
    и
    ч
    е
    с
    к
    о
    е
    л
    и
    ц
    о
    ,
    о
    р
    г
    а
    н
    в
    л
    а
    с
    т
    и
    ,
    м
    е
    с
    т
    н
    о
    г
    о
    с
    а
    м
    о
    у
    п
    р
    а
    в
    л
    е
    н
    и
    я
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, individual=None, legal_entity=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.individual = individual
        self.individual_nsprefix_ = None
        self.legal_entity = legal_entity
        self.legal_entity_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, dissenting_entityType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if dissenting_entityType.subclass:
            return dissenting_entityType.subclass(*args_, **kwargs_)
        else:
            return dissenting_entityType(*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_individual(self):
        return self.individual
    def set_individual(self, individual):
        self.individual = individual
    def get_legal_entity(self):
        return self.legal_entity
    def set_legal_entity(self, legal_entity):
        self.legal_entity = legal_entity
    def has__content(self):
        if (
            self.individual is not None or
            self.legal_entity is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='dissenting_entityType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('dissenting_entityType')
        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_ == 'dissenting_entityType':
            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_='dissenting_entityType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='dissenting_entityType', 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_='dissenting_entityType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='dissenting_entityType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.individual is not None:
            namespaceprefix_ = self.individual_nsprefix_ + ':' if (UseCapturedNS_ and self.individual_nsprefix_) else ''
            self.individual.export(outfile, level, namespaceprefix_, namespacedef_='', name_='individual', pretty_print=pretty_print)
        if self.legal_entity is not None:
            namespaceprefix_ = self.legal_entity_nsprefix_ + ':' if (UseCapturedNS_ and self.legal_entity_nsprefix_) else ''
            self.legal_entity.export(outfile, level, namespaceprefix_, namespacedef_='', name_='legal_entity', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'individual':
            obj_ = Fio.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.individual = obj_
            obj_.original_tagname_ = 'individual'
        elif nodeName_ == 'legal_entity':
            obj_ = Name.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.legal_entity = obj_
            obj_.original_tagname_ = 'legal_entity'
# end class dissenting_entityType


class restriction_encumbranceType(GeneratedsSuper):
    """restriction_encumbranceType -- Н
    е
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    е
    и
    н
    е
    п
    о
    д
    л
    е
    ж
    а
    щ
    е
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    (
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    )
    part_number -- П
    о
    р
    я
    д
    к
    о
    в
    ы
    й
    н
    о
    м
    е
    р
    ч
    а
    с
    т
    и
    encumbrance_type -- В
    и
    д
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    validity -- С
    р
    о
    к
    д
    е
    й
    с
    т
    в
    и
    я
    underlying_docs -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    д
    л
    я
    в
    н
    е
    с
    е
    н
    и
    я
    с
    в
    е
    д
    е
    н
    и
    й
    persons -- Л
    и
    ц
    а
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    о
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    ю
    т
    с
    я
    п
    р
    а
    в
    а
    cad_link -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    content_restrict_encumbrances -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    (
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, part_number=None, encumbrance_type=None, validity=None, underlying_docs=None, persons=None, cad_link=None, content_restrict_encumbrances=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.part_number = part_number
        self.part_number_nsprefix_ = None
        self.encumbrance_type = encumbrance_type
        self.encumbrance_type_nsprefix_ = None
        self.validity = validity
        self.validity_nsprefix_ = None
        self.underlying_docs = underlying_docs
        self.underlying_docs_nsprefix_ = None
        self.persons = persons
        self.persons_nsprefix_ = None
        self.cad_link = cad_link
        self.cad_link_nsprefix_ = None
        self.content_restrict_encumbrances = content_restrict_encumbrances
        self.validate_MultiLiner(self.content_restrict_encumbrances)
        self.content_restrict_encumbrances_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, restriction_encumbranceType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if restriction_encumbranceType.subclass:
            return restriction_encumbranceType.subclass(*args_, **kwargs_)
        else:
            return restriction_encumbranceType(*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_part_number(self):
        return self.part_number
    def set_part_number(self, part_number):
        self.part_number = part_number
    def get_encumbrance_type(self):
        return self.encumbrance_type
    def set_encumbrance_type(self, encumbrance_type):
        self.encumbrance_type = encumbrance_type
    def get_validity(self):
        return self.validity
    def set_validity(self, validity):
        self.validity = validity
    def get_underlying_docs(self):
        return self.underlying_docs
    def set_underlying_docs(self, underlying_docs):
        self.underlying_docs = underlying_docs
    def get_persons(self):
        return self.persons
    def set_persons(self, persons):
        self.persons = persons
    def get_cad_link(self):
        return self.cad_link
    def set_cad_link(self, cad_link):
        self.cad_link = cad_link
    def get_content_restrict_encumbrances(self):
        return self.content_restrict_encumbrances
    def set_content_restrict_encumbrances(self, content_restrict_encumbrances):
        self.content_restrict_encumbrances = content_restrict_encumbrances
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.part_number is not None or
            self.encumbrance_type is not None or
            self.validity is not None or
            self.underlying_docs is not None or
            self.persons is not None or
            self.cad_link is not None or
            self.content_restrict_encumbrances is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restriction_encumbranceType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('restriction_encumbranceType')
        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_ == 'restriction_encumbranceType':
            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_='restriction_encumbranceType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='restriction_encumbranceType', 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_='restriction_encumbranceType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restriction_encumbranceType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.part_number is not None:
            namespaceprefix_ = self.part_number_nsprefix_ + ':' if (UseCapturedNS_ and self.part_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spart_number>%s</%spart_number>%s' % (namespaceprefix_ , self.gds_format_integer(self.part_number, input_name='part_number'), namespaceprefix_ , eol_))
        if self.encumbrance_type is not None:
            namespaceprefix_ = self.encumbrance_type_nsprefix_ + ':' if (UseCapturedNS_ and self.encumbrance_type_nsprefix_) else ''
            self.encumbrance_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='encumbrance_type', pretty_print=pretty_print)
        if self.validity is not None:
            namespaceprefix_ = self.validity_nsprefix_ + ':' if (UseCapturedNS_ and self.validity_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%svalidity>%s</%svalidity>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.validity), input_name='validity')), namespaceprefix_ , eol_))
        if self.underlying_docs is not None:
            namespaceprefix_ = self.underlying_docs_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_docs_nsprefix_) else ''
            self.underlying_docs.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_docs', pretty_print=pretty_print)
        if self.persons is not None:
            namespaceprefix_ = self.persons_nsprefix_ + ':' if (UseCapturedNS_ and self.persons_nsprefix_) else ''
            self.persons.export(outfile, level, namespaceprefix_, namespacedef_='', name_='persons', pretty_print=pretty_print)
        if self.cad_link is not None:
            namespaceprefix_ = self.cad_link_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_link_nsprefix_) else ''
            self.cad_link.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cad_link', pretty_print=pretty_print)
        if self.content_restrict_encumbrances is not None:
            namespaceprefix_ = self.content_restrict_encumbrances_nsprefix_ + ':' if (UseCapturedNS_ and self.content_restrict_encumbrances_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scontent_restrict_encumbrances>%s</%scontent_restrict_encumbrances>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.content_restrict_encumbrances), input_name='content_restrict_encumbrances')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'part_number' and child_.text:
            sval_ = child_.text
            ival_ = self.gds_parse_integer(sval_, node, 'part_number')
            ival_ = self.gds_validate_integer(ival_, node, 'part_number')
            self.part_number = ival_
            self.part_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'encumbrance_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.encumbrance_type = obj_
            obj_.original_tagname_ = 'encumbrance_type'
        elif nodeName_ == 'validity':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'validity')
            value_ = self.gds_validate_string(value_, node, 'validity')
            self.validity = value_
            self.validity_nsprefix_ = child_.prefix
        elif nodeName_ == 'underlying_docs':
            obj_ = UnderlyingDocumentsOutAll.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_docs = obj_
            obj_.original_tagname_ = 'underlying_docs'
        elif nodeName_ == 'persons':
            obj_ = RestrictParties.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.persons = obj_
            obj_.original_tagname_ = 'persons'
        elif nodeName_ == 'cad_link':
            obj_ = CadLinkRestrictions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cad_link = obj_
            obj_.original_tagname_ = 'cad_link'
        elif nodeName_ == 'content_restrict_encumbrances':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'content_restrict_encumbrances')
            value_ = self.gds_validate_string(value_, node, 'content_restrict_encumbrances')
            self.content_restrict_encumbrances = value_
            self.content_restrict_encumbrances_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.content_restrict_encumbrances)
# end class restriction_encumbranceType


class restriction_encumbranceType8(GeneratedsSuper):
    """restriction_encumbranceType8 -- Н
    е
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    е
    и
    н
    е
    п
    о
    д
    л
    е
    ж
    а
    щ
    е
    е
    г
    о
    с
    у
    д
    а
    р
    с
    т
    в
    е
    н
    н
    о
    й
    р
    е
    г
    и
    с
    т
    р
    а
    ц
    и
    и
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    (
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    )
    encumbrance_type -- В
    и
    д
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    validity -- С
    р
    о
    к
    д
    е
    й
    с
    т
    в
    и
    я
    underlying_docs -- Д
    о
    к
    у
    м
    е
    н
    т
    ы
    -
    о
    с
    н
    о
    в
    а
    н
    и
    я
    д
    л
    я
    в
    н
    е
    с
    е
    н
    и
    я
    с
    в
    е
    д
    е
    н
    и
    й
    persons -- Л
    и
    ц
    а
    ,
    в
    п
    о
    л
    ь
    з
    у
    к
    о
    т
    о
    р
    ы
    х
    о
    г
    р
    а
    н
    и
    ч
    и
    в
    а
    ю
    т
    с
    я
    п
    р
    а
    в
    а
    cad_link -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    а
    х
    content_restrict_encumbrances -- С
    о
    д
    е
    р
    ж
    а
    н
    и
    е
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    (
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, encumbrance_type=None, validity=None, underlying_docs=None, persons=None, cad_link=None, content_restrict_encumbrances=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.encumbrance_type = encumbrance_type
        self.encumbrance_type_nsprefix_ = None
        self.validity = validity
        self.validity_nsprefix_ = None
        self.underlying_docs = underlying_docs
        self.underlying_docs_nsprefix_ = None
        self.persons = persons
        self.persons_nsprefix_ = None
        self.cad_link = cad_link
        self.cad_link_nsprefix_ = None
        self.content_restrict_encumbrances = content_restrict_encumbrances
        self.validate_MultiLiner(self.content_restrict_encumbrances)
        self.content_restrict_encumbrances_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, restriction_encumbranceType8)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if restriction_encumbranceType8.subclass:
            return restriction_encumbranceType8.subclass(*args_, **kwargs_)
        else:
            return restriction_encumbranceType8(*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_encumbrance_type(self):
        return self.encumbrance_type
    def set_encumbrance_type(self, encumbrance_type):
        self.encumbrance_type = encumbrance_type
    def get_validity(self):
        return self.validity
    def set_validity(self, validity):
        self.validity = validity
    def get_underlying_docs(self):
        return self.underlying_docs
    def set_underlying_docs(self, underlying_docs):
        self.underlying_docs = underlying_docs
    def get_persons(self):
        return self.persons
    def set_persons(self, persons):
        self.persons = persons
    def get_cad_link(self):
        return self.cad_link
    def set_cad_link(self, cad_link):
        self.cad_link = cad_link
    def get_content_restrict_encumbrances(self):
        return self.content_restrict_encumbrances
    def set_content_restrict_encumbrances(self, content_restrict_encumbrances):
        self.content_restrict_encumbrances = content_restrict_encumbrances
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.encumbrance_type is not None or
            self.validity is not None or
            self.underlying_docs is not None or
            self.persons is not None or
            self.cad_link is not None or
            self.content_restrict_encumbrances is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restriction_encumbranceType8', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('restriction_encumbranceType8')
        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_ == 'restriction_encumbranceType8':
            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_='restriction_encumbranceType8')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='restriction_encumbranceType8', 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_='restriction_encumbranceType8'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restriction_encumbranceType8', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.encumbrance_type is not None:
            namespaceprefix_ = self.encumbrance_type_nsprefix_ + ':' if (UseCapturedNS_ and self.encumbrance_type_nsprefix_) else ''
            self.encumbrance_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='encumbrance_type', pretty_print=pretty_print)
        if self.validity is not None:
            namespaceprefix_ = self.validity_nsprefix_ + ':' if (UseCapturedNS_ and self.validity_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%svalidity>%s</%svalidity>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.validity), input_name='validity')), namespaceprefix_ , eol_))
        if self.underlying_docs is not None:
            namespaceprefix_ = self.underlying_docs_nsprefix_ + ':' if (UseCapturedNS_ and self.underlying_docs_nsprefix_) else ''
            self.underlying_docs.export(outfile, level, namespaceprefix_, namespacedef_='', name_='underlying_docs', pretty_print=pretty_print)
        if self.persons is not None:
            namespaceprefix_ = self.persons_nsprefix_ + ':' if (UseCapturedNS_ and self.persons_nsprefix_) else ''
            self.persons.export(outfile, level, namespaceprefix_, namespacedef_='', name_='persons', pretty_print=pretty_print)
        if self.cad_link is not None:
            namespaceprefix_ = self.cad_link_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_link_nsprefix_) else ''
            self.cad_link.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cad_link', pretty_print=pretty_print)
        if self.content_restrict_encumbrances is not None:
            namespaceprefix_ = self.content_restrict_encumbrances_nsprefix_ + ':' if (UseCapturedNS_ and self.content_restrict_encumbrances_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scontent_restrict_encumbrances>%s</%scontent_restrict_encumbrances>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.content_restrict_encumbrances), input_name='content_restrict_encumbrances')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'encumbrance_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.encumbrance_type = obj_
            obj_.original_tagname_ = 'encumbrance_type'
        elif nodeName_ == 'validity':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'validity')
            value_ = self.gds_validate_string(value_, node, 'validity')
            self.validity = value_
            self.validity_nsprefix_ = child_.prefix
        elif nodeName_ == 'underlying_docs':
            obj_ = UnderlyingDocumentsOutAll.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.underlying_docs = obj_
            obj_.original_tagname_ = 'underlying_docs'
        elif nodeName_ == 'persons':
            obj_ = RestrictParties.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.persons = obj_
            obj_.original_tagname_ = 'persons'
        elif nodeName_ == 'cad_link':
            obj_ = CadLinkRestrictions.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cad_link = obj_
            obj_.original_tagname_ = 'cad_link'
        elif nodeName_ == 'content_restrict_encumbrances':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'content_restrict_encumbrances')
            value_ = self.gds_validate_string(value_, node, 'content_restrict_encumbrances')
            self.content_restrict_encumbrances = value_
            self.content_restrict_encumbrances_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.content_restrict_encumbrances)
# end class restriction_encumbranceType8


class restrict_recordType(GeneratedsSuper):
    """restrict_recordType -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restrictions_encumbrances_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restrictions_encumbrances_data=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.restrictions_encumbrances_data = restrictions_encumbrances_data
        self.restrictions_encumbrances_data_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, restrict_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if restrict_recordType.subclass:
            return restrict_recordType.subclass(*args_, **kwargs_)
        else:
            return restrict_recordType(*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_restrictions_encumbrances_data(self):
        return self.restrictions_encumbrances_data
    def set_restrictions_encumbrances_data(self, restrictions_encumbrances_data):
        self.restrictions_encumbrances_data = restrictions_encumbrances_data
    def has__content(self):
        if (
            self.restrictions_encumbrances_data is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restrict_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('restrict_recordType')
        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_ == 'restrict_recordType':
            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_='restrict_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='restrict_recordType', 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_='restrict_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restrict_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.restrictions_encumbrances_data is not None:
            namespaceprefix_ = self.restrictions_encumbrances_data_nsprefix_ + ':' if (UseCapturedNS_ and self.restrictions_encumbrances_data_nsprefix_) else ''
            self.restrictions_encumbrances_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrictions_encumbrances_data', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restrictions_encumbrances_data':
            obj_ = restrictions_encumbrances_dataType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrictions_encumbrances_data = obj_
            obj_.original_tagname_ = 'restrictions_encumbrances_data'
# end class restrict_recordType


class restrictions_encumbrances_dataType(GeneratedsSuper):
    """restrictions_encumbrances_dataType -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
      
    * restriction_encumbrance_number -- Н
      о
      м
      е
      р
      р
      е
      г
      и
      с
      т
      р
      а
      ц
      и
      и
      о
      г
      р
      а
      н
      и
      ч
      е
      н
      и
      я
      п
      р
      а
      в
      а
      и
      л
      и
      о
      б
      р
      е
      м
      е
      н
      е
      н
      и
      я
      о
      б
      ъ
      е
      к
      т
      а
      н
      е
      д
      в
      и
      ж
      и
      м
      о
      с
      т
      и
    * part_numbers -- П
      о
      р
      я
      д
      к
      о
      в
      ы
      е
      н
      о
      м
      е
      р
      а
      ч
      а
      с
      т
      е
      й
    * restriction_encumbrance_type -- В
      и
      д
      з
      а
      р
      е
      г
      и
      с
      т
      р
      и
      р
      о
      в
      а
      н
      н
      о
      г
      о
      о
      г
      р
      а
      н
      и
      ч
      е
      н
      и
      я
      п
      р
      а
      в
      а
      и
      л
      и
      о
      б
      р
      е
      м
      е
      н
      е
      н
      и
      я
      о
      б
      ъ
      е
      к
      т
      а
      н
      е
      д
      в
      и
      ж
      и
      м
      о
      с
      т
      и
    * restricting_rights -- О
      г
      р
      а
      н
      и
      ч
      и
      в
      а
      е
      м
      ы
      е
      п
      р
      а
      в
      а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restriction_encumbrance_number=None, part_numbers=None, restriction_encumbrance_type=None, restricting_rights=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.restriction_encumbrance_number = restriction_encumbrance_number
        self.restriction_encumbrance_number_nsprefix_ = None
        self.part_numbers = part_numbers
        self.part_numbers_nsprefix_ = None
        self.restriction_encumbrance_type = restriction_encumbrance_type
        self.restriction_encumbrance_type_nsprefix_ = None
        self.restricting_rights = restricting_rights
        self.restricting_rights_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, restrictions_encumbrances_dataType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if restrictions_encumbrances_dataType.subclass:
            return restrictions_encumbrances_dataType.subclass(*args_, **kwargs_)
        else:
            return restrictions_encumbrances_dataType(*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_restriction_encumbrance_number(self):
        return self.restriction_encumbrance_number
    def set_restriction_encumbrance_number(self, restriction_encumbrance_number):
        self.restriction_encumbrance_number = restriction_encumbrance_number
    def get_part_numbers(self):
        return self.part_numbers
    def set_part_numbers(self, part_numbers):
        self.part_numbers = part_numbers
    def get_restriction_encumbrance_type(self):
        return self.restriction_encumbrance_type
    def set_restriction_encumbrance_type(self, restriction_encumbrance_type):
        self.restriction_encumbrance_type = restriction_encumbrance_type
    def get_restricting_rights(self):
        return self.restricting_rights
    def set_restricting_rights(self, restricting_rights):
        self.restricting_rights = restricting_rights
    def has__content(self):
        if (
            self.restriction_encumbrance_number is not None or
            self.part_numbers is not None or
            self.restriction_encumbrance_type is not None or
            self.restricting_rights is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restrictions_encumbrances_dataType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('restrictions_encumbrances_dataType')
        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_ == 'restrictions_encumbrances_dataType':
            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_='restrictions_encumbrances_dataType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='restrictions_encumbrances_dataType', 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_='restrictions_encumbrances_dataType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restrictions_encumbrances_dataType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.restriction_encumbrance_number is not None:
            namespaceprefix_ = self.restriction_encumbrance_number_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%srestriction_encumbrance_number>%s</%srestriction_encumbrance_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.restriction_encumbrance_number), input_name='restriction_encumbrance_number')), namespaceprefix_ , eol_))
        if self.part_numbers is not None:
            namespaceprefix_ = self.part_numbers_nsprefix_ + ':' if (UseCapturedNS_ and self.part_numbers_nsprefix_) else ''
            self.part_numbers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part_numbers', pretty_print=pretty_print)
        if self.restriction_encumbrance_type is not None:
            namespaceprefix_ = self.restriction_encumbrance_type_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_type_nsprefix_) else ''
            self.restriction_encumbrance_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restriction_encumbrance_type', pretty_print=pretty_print)
        if self.restricting_rights is not None:
            namespaceprefix_ = self.restricting_rights_nsprefix_ + ':' if (UseCapturedNS_ and self.restricting_rights_nsprefix_) else ''
            self.restricting_rights.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restricting_rights', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restriction_encumbrance_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'restriction_encumbrance_number')
            value_ = self.gds_validate_string(value_, node, 'restriction_encumbrance_number')
            self.restriction_encumbrance_number = value_
            self.restriction_encumbrance_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'part_numbers':
            obj_ = PartNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.part_numbers = obj_
            obj_.original_tagname_ = 'part_numbers'
        elif nodeName_ == 'restriction_encumbrance_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restriction_encumbrance_type = obj_
            obj_.original_tagname_ = 'restriction_encumbrance_type'
        elif nodeName_ == 'restricting_rights':
            obj_ = RestrictingRightsAllNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restricting_rights = obj_
            obj_.original_tagname_ = 'restricting_rights'
# end class restrictions_encumbrances_dataType


class restrict_recordType9(GeneratedsSuper):
    """restrict_recordType9 -- О
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    restrictions_encumbrances_data -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restrictions_encumbrances_data=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.restrictions_encumbrances_data = restrictions_encumbrances_data
        self.restrictions_encumbrances_data_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, restrict_recordType9)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if restrict_recordType9.subclass:
            return restrict_recordType9.subclass(*args_, **kwargs_)
        else:
            return restrict_recordType9(*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_restrictions_encumbrances_data(self):
        return self.restrictions_encumbrances_data
    def set_restrictions_encumbrances_data(self, restrictions_encumbrances_data):
        self.restrictions_encumbrances_data = restrictions_encumbrances_data
    def has__content(self):
        if (
            self.restrictions_encumbrances_data is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restrict_recordType9', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('restrict_recordType9')
        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_ == 'restrict_recordType9':
            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_='restrict_recordType9')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='restrict_recordType9', 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_='restrict_recordType9'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restrict_recordType9', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.restrictions_encumbrances_data is not None:
            namespaceprefix_ = self.restrictions_encumbrances_data_nsprefix_ + ':' if (UseCapturedNS_ and self.restrictions_encumbrances_data_nsprefix_) else ''
            self.restrictions_encumbrances_data.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restrictions_encumbrances_data', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restrictions_encumbrances_data':
            obj_ = restrictions_encumbrances_dataType10.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restrictions_encumbrances_data = obj_
            obj_.original_tagname_ = 'restrictions_encumbrances_data'
# end class restrict_recordType9


class restrictions_encumbrances_dataType10(GeneratedsSuper):
    """restrictions_encumbrances_dataType10 -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    х
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    х
      
    * restriction_encumbrance_number -- Н
      о
      м
      е
      р
      р
      е
      г
      и
      с
      т
      р
      а
      ц
      и
      и
      о
      г
      р
      а
      н
      и
      ч
      е
      н
      и
      я
      п
      р
      а
      в
      а
      и
      л
      и
      о
      б
      р
      е
      м
      е
      н
      е
      н
      и
      я
      о
      б
      ъ
      е
      к
      т
      а
      н
      е
      д
      в
      и
      ж
      и
      м
      о
      с
      т
      и
    * restriction_encumbrance_type -- В
      и
      д
      з
      а
      р
      е
      г
      и
      с
      т
      р
      и
      р
      о
      в
      а
      н
      н
      о
      г
      о
      о
      г
      р
      а
      н
      и
      ч
      е
      н
      и
      я
      п
      р
      а
      в
      а
      и
      л
      и
      о
      б
      р
      е
      м
      е
      н
      е
      н
      и
      я
      о
      б
      ъ
      е
      к
      т
      а
      н
      е
      д
      в
      и
      ж
      и
      м
      о
      с
      т
      и
    * restricting_rights -- О
      г
      р
      а
      н
      и
      ч
      и
      в
      а
      е
      м
      ы
      е
      п
      р
      а
      в
      а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, restriction_encumbrance_number=None, restriction_encumbrance_type=None, restricting_rights=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.restriction_encumbrance_number = restriction_encumbrance_number
        self.restriction_encumbrance_number_nsprefix_ = None
        self.restriction_encumbrance_type = restriction_encumbrance_type
        self.restriction_encumbrance_type_nsprefix_ = None
        self.restricting_rights = restricting_rights
        self.restricting_rights_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, restrictions_encumbrances_dataType10)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if restrictions_encumbrances_dataType10.subclass:
            return restrictions_encumbrances_dataType10.subclass(*args_, **kwargs_)
        else:
            return restrictions_encumbrances_dataType10(*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_restriction_encumbrance_number(self):
        return self.restriction_encumbrance_number
    def set_restriction_encumbrance_number(self, restriction_encumbrance_number):
        self.restriction_encumbrance_number = restriction_encumbrance_number
    def get_restriction_encumbrance_type(self):
        return self.restriction_encumbrance_type
    def set_restriction_encumbrance_type(self, restriction_encumbrance_type):
        self.restriction_encumbrance_type = restriction_encumbrance_type
    def get_restricting_rights(self):
        return self.restricting_rights
    def set_restricting_rights(self, restricting_rights):
        self.restricting_rights = restricting_rights
    def has__content(self):
        if (
            self.restriction_encumbrance_number is not None or
            self.restriction_encumbrance_type is not None or
            self.restricting_rights is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restrictions_encumbrances_dataType10', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('restrictions_encumbrances_dataType10')
        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_ == 'restrictions_encumbrances_dataType10':
            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_='restrictions_encumbrances_dataType10')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='restrictions_encumbrances_dataType10', 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_='restrictions_encumbrances_dataType10'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='restrictions_encumbrances_dataType10', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.restriction_encumbrance_number is not None:
            namespaceprefix_ = self.restriction_encumbrance_number_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%srestriction_encumbrance_number>%s</%srestriction_encumbrance_number>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.restriction_encumbrance_number), input_name='restriction_encumbrance_number')), namespaceprefix_ , eol_))
        if self.restriction_encumbrance_type is not None:
            namespaceprefix_ = self.restriction_encumbrance_type_nsprefix_ + ':' if (UseCapturedNS_ and self.restriction_encumbrance_type_nsprefix_) else ''
            self.restriction_encumbrance_type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restriction_encumbrance_type', pretty_print=pretty_print)
        if self.restricting_rights is not None:
            namespaceprefix_ = self.restricting_rights_nsprefix_ + ':' if (UseCapturedNS_ and self.restricting_rights_nsprefix_) else ''
            self.restricting_rights.export(outfile, level, namespaceprefix_, namespacedef_='', name_='restricting_rights', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'restriction_encumbrance_number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'restriction_encumbrance_number')
            value_ = self.gds_validate_string(value_, node, 'restriction_encumbrance_number')
            self.restriction_encumbrance_number = value_
            self.restriction_encumbrance_number_nsprefix_ = child_.prefix
        elif nodeName_ == 'restriction_encumbrance_type':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restriction_encumbrance_type = obj_
            obj_.original_tagname_ = 'restriction_encumbrance_type'
        elif nodeName_ == 'restricting_rights':
            obj_ = RestrictingRightsAllNumber.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.restricting_rights = obj_
            obj_.original_tagname_ = 'restricting_rights'
# end class restrictions_encumbrances_dataType10


class periodType(GeneratedsSuper):
    """periodType -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    period_info -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, period_info=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.period_info = period_info
        self.period_info_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, periodType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if periodType.subclass:
            return periodType.subclass(*args_, **kwargs_)
        else:
            return periodType(*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_period_info(self):
        return self.period_info
    def set_period_info(self, period_info):
        self.period_info = period_info
    def has__content(self):
        if (
            self.period_info is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='periodType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('periodType')
        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_ == 'periodType':
            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_='periodType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='periodType', 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_='periodType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='periodType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.period_info is not None:
            namespaceprefix_ = self.period_info_nsprefix_ + ':' if (UseCapturedNS_ and self.period_info_nsprefix_) else ''
            self.period_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='period_info', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'period_info':
            obj_ = period_infoType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.period_info = obj_
            obj_.original_tagname_ = 'period_info'
# end class periodType


class period_infoType(GeneratedsSuper):
    """period_infoType -- С
    р
    о
    к
    ,
    н
    а
    к
    о
    т
    о
    р
    ы
    й
    у
    с
    т
    а
    н
    о
    в
    л
    е
    н
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    е
    п
    р
    а
    в
    а
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    е
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    start_date -- Д
    а
    т
    а
    н
    а
    ч
    а
    л
    а
    д
    е
    й
    с
    т
    в
    и
    я
    end_date -- Д
    а
    т
    а
    п
    р
    е
    к
    р
    а
    щ
    е
    н
    и
    я
    д
    е
    й
    с
    т
    в
    и
    я
    deal_validity_time -- С
    р
    о
    к
    д
    е
    й
    с
    т
    в
    и
    я
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    /
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    (
    П
    р
    о
    д
    о
    л
    ж
    и
    т
    е
    л
    ь
    н
    о
    с
    т
    ь
    )
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, start_date=None, end_date=None, deal_validity_time=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(start_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(start_date, '%Y-%m-%d').date()
        else:
            initvalue_ = start_date
        self.start_date = initvalue_
        self.start_date_nsprefix_ = None
        if isinstance(end_date, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(end_date, '%Y-%m-%d').date()
        else:
            initvalue_ = end_date
        self.end_date = initvalue_
        self.end_date_nsprefix_ = None
        self.deal_validity_time = deal_validity_time
        self.deal_validity_time_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, period_infoType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if period_infoType.subclass:
            return period_infoType.subclass(*args_, **kwargs_)
        else:
            return period_infoType(*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_start_date(self):
        return self.start_date
    def set_start_date(self, start_date):
        self.start_date = start_date
    def get_end_date(self):
        return self.end_date
    def set_end_date(self, end_date):
        self.end_date = end_date
    def get_deal_validity_time(self):
        return self.deal_validity_time
    def set_deal_validity_time(self, deal_validity_time):
        self.deal_validity_time = deal_validity_time
    def has__content(self):
        if (
            self.start_date is not None or
            self.end_date is not None or
            self.deal_validity_time is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='period_infoType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('period_infoType')
        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_ == 'period_infoType':
            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_='period_infoType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='period_infoType', 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_='period_infoType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='period_infoType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.start_date is not None:
            namespaceprefix_ = self.start_date_nsprefix_ + ':' if (UseCapturedNS_ and self.start_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sstart_date>%s</%sstart_date>%s' % (namespaceprefix_ , self.gds_format_date(self.start_date, input_name='start_date'), namespaceprefix_ , eol_))
        if self.end_date is not None:
            namespaceprefix_ = self.end_date_nsprefix_ + ':' if (UseCapturedNS_ and self.end_date_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%send_date>%s</%send_date>%s' % (namespaceprefix_ , self.gds_format_date(self.end_date, input_name='end_date'), namespaceprefix_ , eol_))
        if self.deal_validity_time is not None:
            namespaceprefix_ = self.deal_validity_time_nsprefix_ + ':' if (UseCapturedNS_ and self.deal_validity_time_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdeal_validity_time>%s</%sdeal_validity_time>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.deal_validity_time), input_name='deal_validity_time')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'start_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.start_date = dval_
            self.start_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'end_date':
            sval_ = child_.text
            dval_ = self.gds_parse_date(sval_)
            self.end_date = dval_
            self.end_date_nsprefix_ = child_.prefix
        elif nodeName_ == 'deal_validity_time':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'deal_validity_time')
            value_ = self.gds_validate_string(value_, node, 'deal_validity_time')
            self.deal_validity_time = value_
            self.deal_validity_time_nsprefix_ = child_.prefix
# end class period_infoType


class additional_encumbrance_infoType(GeneratedsSuper):
    """additional_encumbrance_infoType -- Д
    о
    п
    о
    л
    н
    и
    т
    е
    л
    ь
    н
    а
    я
    и
    н
    ф
    о
    р
    м
    а
    ц
    и
    я
    в
    з
    а
    в
    и
    с
    и
    м
    о
    с
    т
    и
    о
    т
    в
    и
    д
    а
    з
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    г
    о
    о
    г
    р
    а
    н
    и
    ч
    е
    н
    и
    я
    п
    р
    а
    в
    а
    и
    л
    и
    о
    б
    р
    е
    м
    е
    н
    е
    н
    и
    я
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    servitude -- С
    е
    р
    в
    и
    т
    у
    т
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, servitude=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.servitude = servitude
        self.servitude_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, additional_encumbrance_infoType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if additional_encumbrance_infoType.subclass:
            return additional_encumbrance_infoType.subclass(*args_, **kwargs_)
        else:
            return additional_encumbrance_infoType(*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_servitude(self):
        return self.servitude
    def set_servitude(self, servitude):
        self.servitude = servitude
    def has__content(self):
        if (
            self.servitude is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='additional_encumbrance_infoType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('additional_encumbrance_infoType')
        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_ == 'additional_encumbrance_infoType':
            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_='additional_encumbrance_infoType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='additional_encumbrance_infoType', 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_='additional_encumbrance_infoType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='additional_encumbrance_infoType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.servitude is not None:
            namespaceprefix_ = self.servitude_nsprefix_ + ':' if (UseCapturedNS_ and self.servitude_nsprefix_) else ''
            self.servitude.export(outfile, level, namespaceprefix_, namespacedef_='', name_='servitude', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'servitude':
            obj_ = servitudeType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.servitude = obj_
            obj_.original_tagname_ = 'servitude'
# end class additional_encumbrance_infoType


class servitudeType(GeneratedsSuper):
    """servitudeType -- С
    е
    р
    в
    и
    т
    у
    т
    servitude_kind -- В
    и
    д
    с
    е
    р
    в
    и
    т
    у
    т
    а
    servitude_condition -- У
    с
    л
    о
    в
    и
    я
    с
    е
    р
    в
    и
    т
    у
    т
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, servitude_kind=None, servitude_condition=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.servitude_kind = servitude_kind
        self.servitude_kind_nsprefix_ = None
        self.servitude_condition = servitude_condition
        self.validate_MultiLiner(self.servitude_condition)
        self.servitude_condition_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, servitudeType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if servitudeType.subclass:
            return servitudeType.subclass(*args_, **kwargs_)
        else:
            return servitudeType(*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_servitude_kind(self):
        return self.servitude_kind
    def set_servitude_kind(self, servitude_kind):
        self.servitude_kind = servitude_kind
    def get_servitude_condition(self):
        return self.servitude_condition
    def set_servitude_condition(self, servitude_condition):
        self.servitude_condition = servitude_condition
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.servitude_kind is not None or
            self.servitude_condition is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='servitudeType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('servitudeType')
        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_ == 'servitudeType':
            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_='servitudeType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='servitudeType', 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_='servitudeType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='servitudeType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.servitude_kind is not None:
            namespaceprefix_ = self.servitude_kind_nsprefix_ + ':' if (UseCapturedNS_ and self.servitude_kind_nsprefix_) else ''
            self.servitude_kind.export(outfile, level, namespaceprefix_, namespacedef_='', name_='servitude_kind', pretty_print=pretty_print)
        if self.servitude_condition is not None:
            namespaceprefix_ = self.servitude_condition_nsprefix_ + ':' if (UseCapturedNS_ and self.servitude_condition_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sservitude_condition>%s</%sservitude_condition>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.servitude_condition), input_name='servitude_condition')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'servitude_kind':
            obj_ = Dict.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.servitude_kind = obj_
            obj_.original_tagname_ = 'servitude_kind'
        elif nodeName_ == 'servitude_condition':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'servitude_condition')
            value_ = self.gds_validate_string(value_, node, 'servitude_condition')
            self.servitude_condition = value_
            self.servitude_condition_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.servitude_condition)
# end class servitudeType


class contoursType(GeneratedsSuper):
    """contoursType -- К
    о
    н
    т
    у
    р
    ы
    г
    р
    а
    н
    и
    ц
    ы
    contour -- К
    о
    н
    т
    у
    р
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, contour=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 contour is None:
            self.contour = []
        else:
            self.contour = contour
        self.contour_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, contoursType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if contoursType.subclass:
            return contoursType.subclass(*args_, **kwargs_)
        else:
            return contoursType(*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_contour(self):
        return self.contour
    def set_contour(self, contour):
        self.contour = contour
    def add_contour(self, value):
        self.contour.append(value)
    def insert_contour_at(self, index, value):
        self.contour.insert(index, value)
    def replace_contour_at(self, index, value):
        self.contour[index] = value
    def has__content(self):
        if (
            self.contour
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='contoursType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('contoursType')
        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_ == 'contoursType':
            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_='contoursType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='contoursType', 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_='contoursType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='contoursType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for contour_ in self.contour:
            namespaceprefix_ = self.contour_nsprefix_ + ':' if (UseCapturedNS_ and self.contour_nsprefix_) else ''
            contour_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contour', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'contour':
            obj_ = ContourZUOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contour.append(obj_)
            obj_.original_tagname_ = 'contour'
# end class contoursType


class plansType(GeneratedsSuper):
    """plansType -- П
    л
    а
    н
    ы
    plan -- П
    л
    а
    н
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, plan=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 plan is None:
            self.plan = []
        else:
            self.plan = plan
        self.plan_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, plansType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if plansType.subclass:
            return plansType.subclass(*args_, **kwargs_)
        else:
            return plansType(*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_plan(self):
        return self.plan
    def set_plan(self, plan):
        self.plan = plan
    def add_plan(self, value):
        self.plan.append(value)
    def insert_plan_at(self, index, value):
        self.plan.insert(index, value)
    def replace_plan_at(self, index, value):
        self.plan[index] = value
    def has__content(self):
        if (
            self.plan
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='plansType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('plansType')
        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_ == 'plansType':
            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_='plansType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='plansType', 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_='plansType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='plansType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for plan_ in self.plan:
            namespaceprefix_ = self.plan_nsprefix_ + ':' if (UseCapturedNS_ and self.plan_nsprefix_) else ''
            plan_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plan', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'plan':
            obj_ = planType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.plan.append(obj_)
            obj_.original_tagname_ = 'plan'
# end class plansType


class planType(GeneratedsSuper):
    """planType -- П
    л
    а
    н
    file_link -- С
    с
    ы
    л
    к
    а
    н
    а
    ф
    а
    й
    л
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, file_link=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.file_link = file_link
        self.file_link_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, planType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if planType.subclass:
            return planType.subclass(*args_, **kwargs_)
        else:
            return planType(*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_file_link(self):
        return self.file_link
    def set_file_link(self, file_link):
        self.file_link = file_link
    def has__content(self):
        if (
            self.file_link is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='planType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('planType')
        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_ == 'planType':
            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_='planType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='planType', 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_='planType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='planType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.file_link is not None:
            namespaceprefix_ = self.file_link_nsprefix_ + ':' if (UseCapturedNS_ and self.file_link_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfile_link>%s</%sfile_link>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.file_link), input_name='file_link')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'file_link':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'file_link')
            value_ = self.gds_validate_string(value_, node, 'file_link')
            self.file_link = value_
            self.file_link_nsprefix_ = child_.prefix
# end class planType


class land_recordsType11(GeneratedsSuper):
    """land_recordsType11 -- З
    е
    м
    е
    л
    ь
    н
    ы
    е
    у
    ч
    а
    с
    т
    к
    и
    land_record -- З
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, land_record=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 land_record is None:
            self.land_record = []
        else:
            self.land_record = land_record
        self.land_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, land_recordsType11)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if land_recordsType11.subclass:
            return land_recordsType11.subclass(*args_, **kwargs_)
        else:
            return land_recordsType11(*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_land_record(self):
        return self.land_record
    def set_land_record(self, land_record):
        self.land_record = land_record
    def add_land_record(self, value):
        self.land_record.append(value)
    def insert_land_record_at(self, index, value):
        self.land_record.insert(index, value)
    def replace_land_record_at(self, index, value):
        self.land_record[index] = value
    def has__content(self):
        if (
            self.land_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='land_recordsType11', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('land_recordsType11')
        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_ == 'land_recordsType11':
            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_='land_recordsType11')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='land_recordsType11', 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_='land_recordsType11'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='land_recordsType11', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for land_record_ in self.land_record:
            namespaceprefix_ = self.land_record_nsprefix_ + ':' if (UseCapturedNS_ and self.land_record_nsprefix_) else ''
            land_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='land_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'land_record':
            obj_ = land_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.land_record.append(obj_)
            obj_.original_tagname_ = 'land_record'
# end class land_recordsType11


class land_recordType(GeneratedsSuper):
    """land_recordType -- З
    е
    м
    е
    л
    ь
    н
    ы
    й
    у
    ч
    а
    с
    т
    о
    к
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
      
    * cad_links -- С
      в
      я
      з
      ь
      с
      к
      а
      д
      а
      с
      т
      р
      о
      в
      ы
      м
      и
      н
      о
      м
      е
      р
      а
      м
      и
      (
      е
      с
      л
      и
      з
      е
      м
      е
      л
      ь
      н
      ы
      й
      у
      ч
      а
      с
      т
      о
      к
      в
      х
      о
      д
      и
      т
      в
      с
      о
      с
      т
      а
      в
      р
      а
      н
      е
      е
      у
      ч
      т
      е
      н
      н
      о
      г
      о
      (
      д
      о
      1
      м
      а
      р
      т
      а
      2008
      г
      .)
      з
      е
      м
      е
      л
      ь
      н
      о
      г
      о
      у
      ч
      а
      с
      т
      к
      а
      ,
      п
      р
      е
      д
      с
      т
      а
      в
      л
      я
      ю
      щ
      е
      г
      о
      с
      о
      б
      о
      й
      е
      д
      и
      н
      о
      е
      з
      е
      м
      л
      е
      п
      о
      л
      ь
      з
      о
      в
      а
      н
      и
      е
      )
    * params -- Х
      а
      р
      а
      к
      т
      е
      р
      и
      с
      т
      и
      к
      и
      з
      е
      м
      е
      л
      ь
      н
      о
      г
      о
      у
      ч
      а
      с
      т
      к
      а
    * address_location -- А
      д
      р
      е
      с
      (
      м
      е
      с
      т
      о
      п
      о
      л
      о
      ж
      е
      н
      и
      е
      )
    * cost -- К
      а
      д
      а
      с
      т
      р
      о
      в
      а
      я
      с
      т
      о
      и
      м
      о
      с
      т
      ь
    * contours_location -- О
      п
      и
      с
      а
      н
      и
      е
      м
      е
      с
      т
      о
      п
      о
      л
      о
      ж
      е
      н
      и
      я
      г
      р
      а
      н
      и
      ц
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, cad_links=None, params=None, address_location=None, cost=None, contours_location=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.object = object
        self.object_nsprefix_ = None
        self.cad_links = cad_links
        self.cad_links_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
        self.cost = cost
        self.cost_nsprefix_ = None
        self.contours_location = contours_location
        self.contours_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, land_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if land_recordType.subclass:
            return land_recordType.subclass(*args_, **kwargs_)
        else:
            return land_recordType(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_cad_links(self):
        return self.cad_links
    def set_cad_links(self, cad_links):
        self.cad_links = cad_links
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def get_cost(self):
        return self.cost
    def set_cost(self, cost):
        self.cost = cost
    def get_contours_location(self):
        return self.contours_location
    def set_contours_location(self, contours_location):
        self.contours_location = contours_location
    def has__content(self):
        if (
            self.object is not None or
            self.cad_links is not None or
            self.params is not None or
            self.address_location is not None or
            self.cost is not None or
            self.contours_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='land_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('land_recordType')
        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_ == 'land_recordType':
            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_='land_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='land_recordType', 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_='land_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='land_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.cad_links is not None:
            namespaceprefix_ = self.cad_links_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_links_nsprefix_) else ''
            self.cad_links.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cad_links', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', pretty_print=pretty_print)
        if self.cost is not None:
            namespaceprefix_ = self.cost_nsprefix_ + ':' if (UseCapturedNS_ and self.cost_nsprefix_) else ''
            self.cost.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cost', pretty_print=pretty_print)
        if self.contours_location is not None:
            namespaceprefix_ = self.contours_location_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_location_nsprefix_) else ''
            self.contours_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectSubType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'cad_links':
            obj_ = CommonLandCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cad_links = obj_
            obj_.original_tagname_ = 'cad_links'
        elif nodeName_ == 'params':
            obj_ = ParamsLandCategoryUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationLand.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
        elif nodeName_ == 'cost':
            obj_ = Cost.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cost = obj_
            obj_.original_tagname_ = 'cost'
        elif nodeName_ == 'contours_location':
            obj_ = ContoursLocationZUZacrep.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours_location = obj_
            obj_.original_tagname_ = 'contours_location'
# end class land_recordType


class build_recordsType12(GeneratedsSuper):
    """build_recordsType12 -- З
    д
    а
    н
    и
    я
    build_record -- З
    д
    а
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, build_record=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 build_record is None:
            self.build_record = []
        else:
            self.build_record = build_record
        self.build_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, build_recordsType12)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if build_recordsType12.subclass:
            return build_recordsType12.subclass(*args_, **kwargs_)
        else:
            return build_recordsType12(*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_build_record(self):
        return self.build_record
    def set_build_record(self, build_record):
        self.build_record = build_record
    def add_build_record(self, value):
        self.build_record.append(value)
    def insert_build_record_at(self, index, value):
        self.build_record.insert(index, value)
    def replace_build_record_at(self, index, value):
        self.build_record[index] = value
    def has__content(self):
        if (
            self.build_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='build_recordsType12', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('build_recordsType12')
        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_ == 'build_recordsType12':
            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_='build_recordsType12')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='build_recordsType12', 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_='build_recordsType12'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='build_recordsType12', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for build_record_ in self.build_record:
            namespaceprefix_ = self.build_record_nsprefix_ + ':' if (UseCapturedNS_ and self.build_record_nsprefix_) else ''
            build_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='build_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'build_record':
            obj_ = build_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.build_record.append(obj_)
            obj_.original_tagname_ = 'build_record'
# end class build_recordsType12


class build_recordType(GeneratedsSuper):
    """build_recordType -- З
    д
    а
    н
    и
    е
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    cad_links -- С
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    (
    с
    в
    е
    д
    е
    н
    и
    я
    о
    в
    х
    о
    ж
    д
    е
    н
    и
    и
    в
    с
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    (
    Е
    Н
    К
    ))
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    з
    д
    а
    н
    и
    я
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    cost -- К
    а
    д
    а
    с
    т
    р
    о
    в
    а
    я
    с
    т
    о
    и
    м
    о
    с
    т
    ь
    (
    д
    л
    я
    в
    х
    о
    д
    я
    щ
    е
    г
    о
    в
    с
    о
    с
    т
    а
    в
    Е
    Н
    К
    -
    к
    а
    д
    а
    с
    т
    р
    о
    в
    а
    я
    с
    т
    о
    и
    м
    о
    с
    т
    ь
    Е
    Н
    К
    )
    contours -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, cad_links=None, params=None, address_location=None, cost=None, contours=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.object = object
        self.object_nsprefix_ = None
        self.cad_links = cad_links
        self.cad_links_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
        self.cost = cost
        self.cost_nsprefix_ = None
        self.contours = contours
        self.contours_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, build_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if build_recordType.subclass:
            return build_recordType.subclass(*args_, **kwargs_)
        else:
            return build_recordType(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_cad_links(self):
        return self.cad_links
    def set_cad_links(self, cad_links):
        self.cad_links = cad_links
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def get_cost(self):
        return self.cost
    def set_cost(self, cost):
        self.cost = cost
    def get_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def has__content(self):
        if (
            self.object is not None or
            self.cad_links is not None or
            self.params is not None or
            self.address_location is not None or
            self.cost is not None or
            self.contours is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='build_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('build_recordType')
        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_ == 'build_recordType':
            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_='build_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='build_recordType', 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_='build_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='build_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.cad_links is not None:
            namespaceprefix_ = self.cad_links_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_links_nsprefix_) else ''
            self.cad_links.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cad_links', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', pretty_print=pretty_print)
        if self.cost is not None:
            namespaceprefix_ = self.cost_nsprefix_ + ':' if (UseCapturedNS_ and self.cost_nsprefix_) else ''
            self.cost.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cost', pretty_print=pretty_print)
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'cad_links':
            obj_ = UnitedCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cad_links = obj_
            obj_.original_tagname_ = 'cad_links'
        elif nodeName_ == 'params':
            obj_ = ParamsBuildPurposeUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationBuild.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
        elif nodeName_ == 'cost':
            obj_ = Cost.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cost = obj_
            obj_.original_tagname_ = 'cost'
        elif nodeName_ == 'contours':
            obj_ = ContoursOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
# end class build_recordType


class construction_recordsType13(GeneratedsSuper):
    """construction_recordsType13 -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    construction_record -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    е
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, construction_record=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 construction_record is None:
            self.construction_record = []
        else:
            self.construction_record = construction_record
        self.construction_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, construction_recordsType13)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if construction_recordsType13.subclass:
            return construction_recordsType13.subclass(*args_, **kwargs_)
        else:
            return construction_recordsType13(*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_construction_record(self):
        return self.construction_record
    def set_construction_record(self, construction_record):
        self.construction_record = construction_record
    def add_construction_record(self, value):
        self.construction_record.append(value)
    def insert_construction_record_at(self, index, value):
        self.construction_record.insert(index, value)
    def replace_construction_record_at(self, index, value):
        self.construction_record[index] = value
    def has__content(self):
        if (
            self.construction_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='construction_recordsType13', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('construction_recordsType13')
        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_ == 'construction_recordsType13':
            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_='construction_recordsType13')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='construction_recordsType13', 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_='construction_recordsType13'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='construction_recordsType13', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for construction_record_ in self.construction_record:
            namespaceprefix_ = self.construction_record_nsprefix_ + ':' if (UseCapturedNS_ and self.construction_record_nsprefix_) else ''
            construction_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='construction_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'construction_record':
            obj_ = construction_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.construction_record.append(obj_)
            obj_.original_tagname_ = 'construction_record'
# end class construction_recordsType13


class construction_recordType(GeneratedsSuper):
    """construction_recordType -- С
    о
    о
    р
    у
    ж
    е
    н
    и
    е
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    cad_links -- С
    в
    я
    з
    ь
    с
    к
    а
    д
    а
    с
    т
    р
    о
    в
    ы
    м
    и
    н
    о
    м
    е
    р
    а
    м
    и
    (
    с
    в
    е
    д
    е
    н
    и
    я
    о
    в
    х
    о
    ж
    д
    е
    н
    и
    и
    в
    с
    о
    с
    т
    а
    в
    е
    д
    и
    н
    о
    г
    о
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    г
    о
    к
    о
    м
    п
    л
    е
    к
    с
    а
    (
    Е
    Н
    К
    ))
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    с
    о
    о
    р
    у
    ж
    е
    н
    и
    я
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    cost -- К
    а
    д
    а
    с
    т
    р
    о
    в
    а
    я
    с
    т
    о
    и
    м
    о
    с
    т
    ь
    (
    д
    л
    я
    в
    х
    о
    д
    я
    щ
    е
    г
    о
    в
    с
    о
    с
    т
    а
    в
    Е
    Н
    К
    -
    к
    а
    д
    а
    с
    т
    р
    о
    в
    а
    я
    с
    т
    о
    и
    м
    о
    с
    т
    ь
    Е
    Н
    К
    )
    contours -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, cad_links=None, params=None, address_location=None, cost=None, contours=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.object = object
        self.object_nsprefix_ = None
        self.cad_links = cad_links
        self.cad_links_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
        self.cost = cost
        self.cost_nsprefix_ = None
        self.contours = contours
        self.contours_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, construction_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if construction_recordType.subclass:
            return construction_recordType.subclass(*args_, **kwargs_)
        else:
            return construction_recordType(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_cad_links(self):
        return self.cad_links
    def set_cad_links(self, cad_links):
        self.cad_links = cad_links
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def get_cost(self):
        return self.cost
    def set_cost(self, cost):
        self.cost = cost
    def get_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def has__content(self):
        if (
            self.object is not None or
            self.cad_links is not None or
            self.params is not None or
            self.address_location is not None or
            self.cost is not None or
            self.contours is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='construction_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('construction_recordType')
        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_ == 'construction_recordType':
            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_='construction_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='construction_recordType', 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_='construction_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='construction_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.cad_links is not None:
            namespaceprefix_ = self.cad_links_nsprefix_ + ':' if (UseCapturedNS_ and self.cad_links_nsprefix_) else ''
            self.cad_links.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cad_links', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', pretty_print=pretty_print)
        if self.cost is not None:
            namespaceprefix_ = self.cost_nsprefix_ + ':' if (UseCapturedNS_ and self.cost_nsprefix_) else ''
            self.cost.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cost', pretty_print=pretty_print)
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'cad_links':
            obj_ = UnitedCadNumbers.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cad_links = obj_
            obj_.original_tagname_ = 'cad_links'
        elif nodeName_ == 'params':
            obj_ = ParamsConstructionPurposeUses.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationConstruction.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
        elif nodeName_ == 'cost':
            obj_ = Cost.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cost = obj_
            obj_.original_tagname_ = 'cost'
        elif nodeName_ == 'contours':
            obj_ = ContoursOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
# end class construction_recordType


class object_under_construction_recordsType14(GeneratedsSuper):
    """object_under_construction_recordsType14 -- О
    б
    ъ
    е
    к
    т
    ы
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    object_under_construction_record -- О
    б
    ъ
    е
    к
    т
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object_under_construction_record=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 object_under_construction_record is None:
            self.object_under_construction_record = []
        else:
            self.object_under_construction_record = object_under_construction_record
        self.object_under_construction_record_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, object_under_construction_recordsType14)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if object_under_construction_recordsType14.subclass:
            return object_under_construction_recordsType14.subclass(*args_, **kwargs_)
        else:
            return object_under_construction_recordsType14(*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_object_under_construction_record(self):
        return self.object_under_construction_record
    def set_object_under_construction_record(self, object_under_construction_record):
        self.object_under_construction_record = object_under_construction_record
    def add_object_under_construction_record(self, value):
        self.object_under_construction_record.append(value)
    def insert_object_under_construction_record_at(self, index, value):
        self.object_under_construction_record.insert(index, value)
    def replace_object_under_construction_record_at(self, index, value):
        self.object_under_construction_record[index] = value
    def has__content(self):
        if (
            self.object_under_construction_record
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='object_under_construction_recordsType14', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('object_under_construction_recordsType14')
        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_ == 'object_under_construction_recordsType14':
            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_='object_under_construction_recordsType14')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='object_under_construction_recordsType14', 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_='object_under_construction_recordsType14'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='object_under_construction_recordsType14', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for object_under_construction_record_ in self.object_under_construction_record:
            namespaceprefix_ = self.object_under_construction_record_nsprefix_ + ':' if (UseCapturedNS_ and self.object_under_construction_record_nsprefix_) else ''
            object_under_construction_record_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object_under_construction_record', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object_under_construction_record':
            obj_ = object_under_construction_recordType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object_under_construction_record.append(obj_)
            obj_.original_tagname_ = 'object_under_construction_record'
# end class object_under_construction_recordsType14


class object_under_construction_recordType(GeneratedsSuper):
    """object_under_construction_recordType -- О
    б
    ъ
    е
    к
    т
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    object -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    о
    б
    ъ
    е
    к
    т
    е
    н
    е
    д
    в
    и
    ж
    и
    м
    о
    с
    т
    и
    params -- Х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    и
    о
    б
    ъ
    е
    к
    т
    а
    н
    е
    з
    а
    в
    е
    р
    ш
    е
    н
    н
    о
    г
    о
    с
    т
    р
    о
    и
    т
    е
    л
    ь
    с
    т
    в
    а
    (
    п
    р
    о
    е
    к
    т
    и
    р
    у
    е
    м
    ы
    е
    з
    н
    а
    ч
    е
    н
    и
    я
    о
    с
    н
    о
    в
    н
    ы
    х
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    ,
    н
    а
    з
    н
    а
    ч
    е
    н
    и
    я
    )
    address_location -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    cost -- К
    а
    д
    а
    с
    т
    р
    о
    в
    а
    я
    с
    т
    о
    и
    м
    о
    с
    т
    ь
    contours -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    к
    о
    н
    т
    у
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, object=None, params=None, address_location=None, cost=None, contours=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.object = object
        self.object_nsprefix_ = None
        self.params = params
        self.params_nsprefix_ = None
        self.address_location = address_location
        self.address_location_nsprefix_ = None
        self.cost = cost
        self.cost_nsprefix_ = None
        self.contours = contours
        self.contours_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, object_under_construction_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if object_under_construction_recordType.subclass:
            return object_under_construction_recordType.subclass(*args_, **kwargs_)
        else:
            return object_under_construction_recordType(*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_object(self):
        return self.object
    def set_object(self, object):
        self.object = object
    def get_params(self):
        return self.params
    def set_params(self, params):
        self.params = params
    def get_address_location(self):
        return self.address_location
    def set_address_location(self, address_location):
        self.address_location = address_location
    def get_cost(self):
        return self.cost
    def set_cost(self, cost):
        self.cost = cost
    def get_contours(self):
        return self.contours
    def set_contours(self, contours):
        self.contours = contours
    def has__content(self):
        if (
            self.object is not None or
            self.params is not None or
            self.address_location is not None or
            self.cost is not None or
            self.contours is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='object_under_construction_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('object_under_construction_recordType')
        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_ == 'object_under_construction_recordType':
            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_='object_under_construction_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='object_under_construction_recordType', 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_='object_under_construction_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='object_under_construction_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.object is not None:
            namespaceprefix_ = self.object_nsprefix_ + ':' if (UseCapturedNS_ and self.object_nsprefix_) else ''
            self.object.export(outfile, level, namespaceprefix_, namespacedef_='', name_='object', pretty_print=pretty_print)
        if self.params is not None:
            namespaceprefix_ = self.params_nsprefix_ + ':' if (UseCapturedNS_ and self.params_nsprefix_) else ''
            self.params.export(outfile, level, namespaceprefix_, namespacedef_='', name_='params', pretty_print=pretty_print)
        if self.address_location is not None:
            namespaceprefix_ = self.address_location_nsprefix_ + ':' if (UseCapturedNS_ and self.address_location_nsprefix_) else ''
            self.address_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='address_location', pretty_print=pretty_print)
        if self.cost is not None:
            namespaceprefix_ = self.cost_nsprefix_ + ':' if (UseCapturedNS_ and self.cost_nsprefix_) else ''
            self.cost.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cost', pretty_print=pretty_print)
        if self.contours is not None:
            namespaceprefix_ = self.contours_nsprefix_ + ':' if (UseCapturedNS_ and self.contours_nsprefix_) else ''
            self.contours.export(outfile, level, namespaceprefix_, namespacedef_='', name_='contours', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'object':
            obj_ = ObjectType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.object = obj_
            obj_.original_tagname_ = 'object'
        elif nodeName_ == 'params':
            obj_ = ParamsConstructionPurpose.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.params = obj_
            obj_.original_tagname_ = 'params'
        elif nodeName_ == 'address_location':
            obj_ = AddressLocationConstruction.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.address_location = obj_
            obj_.original_tagname_ = 'address_location'
        elif nodeName_ == 'cost':
            obj_ = Cost.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.cost = obj_
            obj_.original_tagname_ = 'cost'
        elif nodeName_ == 'contours':
            obj_ = ContoursOKSOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.contours = obj_
            obj_.original_tagname_ = 'contours'
# end class object_under_construction_recordType


class subject_boundary_recordType(GeneratedsSuper):
    """subject_boundary_recordType -- Г
    р
    а
    н
    и
    ц
    а
    м
    е
    ж
    д
    у
    с
    у
    б
    ъ
    е
    к
    т
    а
    м
    и
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    record_info -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    н
    а
    у
    ч
    е
    т
    (
    п
    р
    и
    с
    в
    о
    е
    н
    и
    я
    н
    о
    м
    е
    р
    а
    )
    b_object_subject_boundary -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    е
    м
    е
    ж
    д
    у
    с
    у
    б
    ъ
    е
    к
    т
    а
    м
    и
    Р
    о
    с
    с
    и
    й
    с
    к
    о
    й
    Ф
    е
    д
    е
    р
    а
    ц
    и
    и
    b_contours_location -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, b_object_subject_boundary=None, b_contours_location=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.b_object_subject_boundary = b_object_subject_boundary
        self.b_object_subject_boundary_nsprefix_ = None
        self.b_contours_location = b_contours_location
        self.b_contours_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, subject_boundary_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if subject_boundary_recordType.subclass:
            return subject_boundary_recordType.subclass(*args_, **kwargs_)
        else:
            return subject_boundary_recordType(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_b_object_subject_boundary(self):
        return self.b_object_subject_boundary
    def set_b_object_subject_boundary(self, b_object_subject_boundary):
        self.b_object_subject_boundary = b_object_subject_boundary
    def get_b_contours_location(self):
        return self.b_contours_location
    def set_b_contours_location(self, b_contours_location):
        self.b_contours_location = b_contours_location
    def has__content(self):
        if (
            self.record_info is not None or
            self.b_object_subject_boundary is not None or
            self.b_contours_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='subject_boundary_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('subject_boundary_recordType')
        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_ == 'subject_boundary_recordType':
            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_='subject_boundary_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='subject_boundary_recordType', 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_='subject_boundary_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='subject_boundary_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.b_object_subject_boundary is not None:
            namespaceprefix_ = self.b_object_subject_boundary_nsprefix_ + ':' if (UseCapturedNS_ and self.b_object_subject_boundary_nsprefix_) else ''
            self.b_object_subject_boundary.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_object_subject_boundary', pretty_print=pretty_print)
        if self.b_contours_location is not None:
            namespaceprefix_ = self.b_contours_location_nsprefix_ + ':' if (UseCapturedNS_ and self.b_contours_location_nsprefix_) else ''
            self.b_contours_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_contours_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RecordInfoDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'b_object_subject_boundary':
            obj_ = BobjectSubjectBoundary.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_object_subject_boundary = obj_
            obj_.original_tagname_ = 'b_object_subject_boundary'
        elif nodeName_ == 'b_contours_location':
            obj_ = BoundContoursLocationOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_contours_location = obj_
            obj_.original_tagname_ = 'b_contours_location'
# end class subject_boundary_recordType


class municipal_boundary_recordType(GeneratedsSuper):
    """municipal_boundary_recordType -- Г
    р
    а
    н
    и
    ц
    а
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    о
    г
    о
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    я
    record_info -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    н
    а
    у
    ч
    е
    т
    (
    п
    р
    и
    с
    в
    о
    е
    н
    и
    я
    н
    о
    м
    е
    р
    а
    )
    b_object_municipal_boundary -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    е
    м
    у
    н
    и
    ц
    и
    п
    а
    л
    ь
    н
    о
    г
    о
    о
    б
    р
    а
    з
    о
    в
    а
    н
    и
    я
    b_contours_location -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, b_object_municipal_boundary=None, b_contours_location=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.b_object_municipal_boundary = b_object_municipal_boundary
        self.b_object_municipal_boundary_nsprefix_ = None
        self.b_contours_location = b_contours_location
        self.b_contours_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, municipal_boundary_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if municipal_boundary_recordType.subclass:
            return municipal_boundary_recordType.subclass(*args_, **kwargs_)
        else:
            return municipal_boundary_recordType(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_b_object_municipal_boundary(self):
        return self.b_object_municipal_boundary
    def set_b_object_municipal_boundary(self, b_object_municipal_boundary):
        self.b_object_municipal_boundary = b_object_municipal_boundary
    def get_b_contours_location(self):
        return self.b_contours_location
    def set_b_contours_location(self, b_contours_location):
        self.b_contours_location = b_contours_location
    def has__content(self):
        if (
            self.record_info is not None or
            self.b_object_municipal_boundary is not None or
            self.b_contours_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='municipal_boundary_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('municipal_boundary_recordType')
        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_ == 'municipal_boundary_recordType':
            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_='municipal_boundary_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='municipal_boundary_recordType', 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_='municipal_boundary_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='municipal_boundary_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.b_object_municipal_boundary is not None:
            namespaceprefix_ = self.b_object_municipal_boundary_nsprefix_ + ':' if (UseCapturedNS_ and self.b_object_municipal_boundary_nsprefix_) else ''
            self.b_object_municipal_boundary.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_object_municipal_boundary', pretty_print=pretty_print)
        if self.b_contours_location is not None:
            namespaceprefix_ = self.b_contours_location_nsprefix_ + ':' if (UseCapturedNS_ and self.b_contours_location_nsprefix_) else ''
            self.b_contours_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_contours_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RecordInfoDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'b_object_municipal_boundary':
            obj_ = BobjectMunicipalInhabitedBoundary.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_object_municipal_boundary = obj_
            obj_.original_tagname_ = 'b_object_municipal_boundary'
        elif nodeName_ == 'b_contours_location':
            obj_ = BoundContoursLocationOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_contours_location = obj_
            obj_.original_tagname_ = 'b_contours_location'
# end class municipal_boundary_recordType


class inhabited_locality_boundary_recordType(GeneratedsSuper):
    """inhabited_locality_boundary_recordType -- Г
    р
    а
    н
    и
    ц
    а
    н
    а
    с
    е
    л
    ё
    н
    н
    о
    г
    о
    п
    у
    н
    к
    т
    а
    record_info -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    н
    а
    у
    ч
    е
    т
    (
    п
    р
    и
    с
    в
    о
    е
    н
    и
    я
    н
    о
    м
    е
    р
    а
    )
    b_object_inhabited_locality_boundary -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    г
    р
    а
    н
    и
    ц
    е
    н
    а
    с
    е
    л
    ё
    н
    н
    о
    г
    о
    п
    у
    н
    к
    т
    а
    b_contours_location -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, b_object_inhabited_locality_boundary=None, b_contours_location=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.b_object_inhabited_locality_boundary = b_object_inhabited_locality_boundary
        self.b_object_inhabited_locality_boundary_nsprefix_ = None
        self.b_contours_location = b_contours_location
        self.b_contours_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, inhabited_locality_boundary_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if inhabited_locality_boundary_recordType.subclass:
            return inhabited_locality_boundary_recordType.subclass(*args_, **kwargs_)
        else:
            return inhabited_locality_boundary_recordType(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_b_object_inhabited_locality_boundary(self):
        return self.b_object_inhabited_locality_boundary
    def set_b_object_inhabited_locality_boundary(self, b_object_inhabited_locality_boundary):
        self.b_object_inhabited_locality_boundary = b_object_inhabited_locality_boundary
    def get_b_contours_location(self):
        return self.b_contours_location
    def set_b_contours_location(self, b_contours_location):
        self.b_contours_location = b_contours_location
    def has__content(self):
        if (
            self.record_info is not None or
            self.b_object_inhabited_locality_boundary is not None or
            self.b_contours_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='inhabited_locality_boundary_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('inhabited_locality_boundary_recordType')
        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_ == 'inhabited_locality_boundary_recordType':
            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_='inhabited_locality_boundary_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='inhabited_locality_boundary_recordType', 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_='inhabited_locality_boundary_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='inhabited_locality_boundary_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.b_object_inhabited_locality_boundary is not None:
            namespaceprefix_ = self.b_object_inhabited_locality_boundary_nsprefix_ + ':' if (UseCapturedNS_ and self.b_object_inhabited_locality_boundary_nsprefix_) else ''
            self.b_object_inhabited_locality_boundary.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_object_inhabited_locality_boundary', pretty_print=pretty_print)
        if self.b_contours_location is not None:
            namespaceprefix_ = self.b_contours_location_nsprefix_ + ':' if (UseCapturedNS_ and self.b_contours_location_nsprefix_) else ''
            self.b_contours_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_contours_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RecordInfoDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'b_object_inhabited_locality_boundary':
            obj_ = BobjectMunicipalInhabitedBoundary.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_object_inhabited_locality_boundary = obj_
            obj_.original_tagname_ = 'b_object_inhabited_locality_boundary'
        elif nodeName_ == 'b_contours_location':
            obj_ = BoundContoursLocationOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_contours_location = obj_
            obj_.original_tagname_ = 'b_contours_location'
# end class inhabited_locality_boundary_recordType


class coastline_recordType(GeneratedsSuper):
    """coastline_recordType -- Б
    е
    р
    е
    г
    о
    в
    а
    я
    л
    и
    н
    и
    я
    (
    г
    р
    а
    н
    и
    ц
    а
    в
    о
    д
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    )
    record_info -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    н
    а
    у
    ч
    е
    т
    (
    п
    р
    и
    с
    в
    о
    е
    н
    и
    я
    н
    о
    м
    е
    р
    а
    )
    b_object_coastline -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    е
    р
    е
    г
    о
    в
    о
    й
    л
    и
    н
    и
    и
    (
    г
    р
    а
    н
    и
    ц
    е
    в
    о
    д
    н
    о
    г
    о
    о
    б
    ъ
    е
    к
    т
    а
    )
    b_contours_location -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, b_object_coastline=None, b_contours_location=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.b_object_coastline = b_object_coastline
        self.b_object_coastline_nsprefix_ = None
        self.b_contours_location = b_contours_location
        self.b_contours_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, coastline_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if coastline_recordType.subclass:
            return coastline_recordType.subclass(*args_, **kwargs_)
        else:
            return coastline_recordType(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_b_object_coastline(self):
        return self.b_object_coastline
    def set_b_object_coastline(self, b_object_coastline):
        self.b_object_coastline = b_object_coastline
    def get_b_contours_location(self):
        return self.b_contours_location
    def set_b_contours_location(self, b_contours_location):
        self.b_contours_location = b_contours_location
    def has__content(self):
        if (
            self.record_info is not None or
            self.b_object_coastline is not None or
            self.b_contours_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='coastline_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('coastline_recordType')
        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_ == 'coastline_recordType':
            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_='coastline_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='coastline_recordType', 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_='coastline_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='coastline_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.b_object_coastline is not None:
            namespaceprefix_ = self.b_object_coastline_nsprefix_ + ':' if (UseCapturedNS_ and self.b_object_coastline_nsprefix_) else ''
            self.b_object_coastline.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_object_coastline', pretty_print=pretty_print)
        if self.b_contours_location is not None:
            namespaceprefix_ = self.b_contours_location_nsprefix_ + ':' if (UseCapturedNS_ and self.b_contours_location_nsprefix_) else ''
            self.b_contours_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_contours_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RecordInfoDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'b_object_coastline':
            obj_ = BobjectCoastline.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_object_coastline = obj_
            obj_.original_tagname_ = 'b_object_coastline'
        elif nodeName_ == 'b_contours_location':
            obj_ = BoundContoursLocationOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_contours_location = obj_
            obj_.original_tagname_ = 'b_contours_location'
# end class coastline_recordType


class zones_and_territories_recordType(GeneratedsSuper):
    """zones_and_territories_recordType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    з
    о
    н
    е
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    ,
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    е
    ,
    л
    е
    с
    о
    п
    а
    р
    к
    е
    ,
    о
    х
    о
    т
    н
    и
    ч
    ь
    е
    м
    у
    г
    о
    д
    ь
    е
    record_info -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    н
    а
    у
    ч
    е
    т
    (
    п
    р
    и
    с
    в
    о
    е
    н
    и
    я
    н
    о
    м
    е
    р
    а
    )
    b_object_zones_and_territories -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    з
    о
    н
    е
    ,
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    ,
    л
    е
    с
    н
    и
    ч
    е
    с
    т
    в
    е
    ,
    л
    е
    с
    о
    п
    а
    р
    к
    е
    ,
    о
    х
    о
    т
    н
    и
    ч
    ь
    е
    м
    у
    г
    о
    д
    ь
    е
    b_contours_location -- О
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    г
    р
    а
    н
    и
    ц
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, b_object_zones_and_territories=None, b_contours_location=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.b_object_zones_and_territories = b_object_zones_and_territories
        self.b_object_zones_and_territories_nsprefix_ = None
        self.b_contours_location = b_contours_location
        self.b_contours_location_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, zones_and_territories_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if zones_and_territories_recordType.subclass:
            return zones_and_territories_recordType.subclass(*args_, **kwargs_)
        else:
            return zones_and_territories_recordType(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_b_object_zones_and_territories(self):
        return self.b_object_zones_and_territories
    def set_b_object_zones_and_territories(self, b_object_zones_and_territories):
        self.b_object_zones_and_territories = b_object_zones_and_territories
    def get_b_contours_location(self):
        return self.b_contours_location
    def set_b_contours_location(self, b_contours_location):
        self.b_contours_location = b_contours_location
    def has__content(self):
        if (
            self.record_info is not None or
            self.b_object_zones_and_territories is not None or
            self.b_contours_location is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='zones_and_territories_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('zones_and_territories_recordType')
        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_ == 'zones_and_territories_recordType':
            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_='zones_and_territories_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='zones_and_territories_recordType', 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_='zones_and_territories_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='zones_and_territories_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.b_object_zones_and_territories is not None:
            namespaceprefix_ = self.b_object_zones_and_territories_nsprefix_ + ':' if (UseCapturedNS_ and self.b_object_zones_and_territories_nsprefix_) else ''
            self.b_object_zones_and_territories.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_object_zones_and_territories', pretty_print=pretty_print)
        if self.b_contours_location is not None:
            namespaceprefix_ = self.b_contours_location_nsprefix_ + ':' if (UseCapturedNS_ and self.b_contours_location_nsprefix_) else ''
            self.b_contours_location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_contours_location', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RecordInfoDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'b_object_zones_and_territories':
            obj_ = BobjectZonesAndTerritories.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_object_zones_and_territories = obj_
            obj_.original_tagname_ = 'b_object_zones_and_territories'
        elif nodeName_ == 'b_contours_location':
            obj_ = BoundContoursLocationOut.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_contours_location = obj_
            obj_.original_tagname_ = 'b_contours_location'
# end class zones_and_territories_recordType


class surveying_project_recordType(GeneratedsSuper):
    """surveying_project_recordType -- С
    в
    е
    д
    е
    н
    и
    я
    о
    б
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    н
    о
    м
    п
    р
    о
    е
    к
    т
    е
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    т
    е
    р
    р
    и
    т
    о
    р
    и
    и
    и
    о
    б
    о
    б
    р
    а
    з
    у
    е
    м
    ы
    х
    з
    е
    м
    е
    л
    ь
    н
    ы
    х
    у
    ч
    а
    с
    т
    к
    а
    х
    record_info -- Д
    а
    т
    а
    п
    о
    с
    т
    а
    н
    о
    в
    к
    и
    н
    а
    у
    ч
    е
    т
    (
    п
    р
    и
    с
    в
    о
    е
    н
    и
    я
    н
    о
    м
    е
    р
    а
    )
    b_object_surveying_project -- О
    б
    щ
    и
    е
    с
    в
    е
    д
    е
    н
    и
    я
    о
    б
    у
    т
    в
    е
    р
    ж
    д
    е
    н
    н
    о
    м
    п
    р
    о
    е
    к
    т
    е
    м
    е
    ж
    е
    в
    а
    н
    и
    я
    forming_parcels -- О
    б
    р
    а
    з
    у
    е
    м
    ы
    е
    з
    е
    м
    е
    л
    ь
    н
    ы
    е
    у
    ч
    а
    с
    т
    к
    и
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, record_info=None, b_object_surveying_project=None, forming_parcels=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.record_info = record_info
        self.record_info_nsprefix_ = None
        self.b_object_surveying_project = b_object_surveying_project
        self.b_object_surveying_project_nsprefix_ = None
        self.forming_parcels = forming_parcels
        self.forming_parcels_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, surveying_project_recordType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if surveying_project_recordType.subclass:
            return surveying_project_recordType.subclass(*args_, **kwargs_)
        else:
            return surveying_project_recordType(*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_record_info(self):
        return self.record_info
    def set_record_info(self, record_info):
        self.record_info = record_info
    def get_b_object_surveying_project(self):
        return self.b_object_surveying_project
    def set_b_object_surveying_project(self, b_object_surveying_project):
        self.b_object_surveying_project = b_object_surveying_project
    def get_forming_parcels(self):
        return self.forming_parcels
    def set_forming_parcels(self, forming_parcels):
        self.forming_parcels = forming_parcels
    def has__content(self):
        if (
            self.record_info is not None or
            self.b_object_surveying_project is not None or
            self.forming_parcels is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='surveying_project_recordType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('surveying_project_recordType')
        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_ == 'surveying_project_recordType':
            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_='surveying_project_recordType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='surveying_project_recordType', 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_='surveying_project_recordType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='surveying_project_recordType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.record_info is not None:
            namespaceprefix_ = self.record_info_nsprefix_ + ':' if (UseCapturedNS_ and self.record_info_nsprefix_) else ''
            self.record_info.export(outfile, level, namespaceprefix_, namespacedef_='', name_='record_info', pretty_print=pretty_print)
        if self.b_object_surveying_project is not None:
            namespaceprefix_ = self.b_object_surveying_project_nsprefix_ + ':' if (UseCapturedNS_ and self.b_object_surveying_project_nsprefix_) else ''
            self.b_object_surveying_project.export(outfile, level, namespaceprefix_, namespacedef_='', name_='b_object_surveying_project', pretty_print=pretty_print)
        if self.forming_parcels is not None:
            namespaceprefix_ = self.forming_parcels_nsprefix_ + ':' if (UseCapturedNS_ and self.forming_parcels_nsprefix_) else ''
            self.forming_parcels.export(outfile, level, namespaceprefix_, namespacedef_='', name_='forming_parcels', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'record_info':
            obj_ = RecordInfoDate.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.record_info = obj_
            obj_.original_tagname_ = 'record_info'
        elif nodeName_ == 'b_object_surveying_project':
            obj_ = BobjectSurveyingProject.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.b_object_surveying_project = obj_
            obj_.original_tagname_ = 'b_object_surveying_project'
        elif nodeName_ == 'forming_parcels':
            obj_ = FormingParcelsNumberContours.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.forming_parcels = obj_
            obj_.original_tagname_ = 'forming_parcels'
# end class surveying_project_recordType


class base_parameterType(GeneratedsSuper):
    """base_parameterType -- О
    с
    н
    о
    в
    н
    а
    я
    х
    а
    р
    а
    к
    т
    е
    р
    и
    с
    т
    и
    к
    а
    area -- П
    л
    о
    щ
    а
    д
    ь
    в
    к
    в
    .
    м
    е
    т
    р
    а
    х
    built_up_area -- П
    л
    о
    щ
    а
    д
    ь
    з
    а
    с
    т
    р
    о
    й
    к
    и
    в
    к
    в
    а
    д
    р
    а
    т
    н
    ы
    х
    м
    е
    т
    р
    а
    х
    с
    о
    к
    р
    у
    г
    л
    е
    н
    и
    е
    м
    д
    о
    0,1
    к
    в
    а
    д
    р
    а
    т
    н
    о
    г
    о
    м
    е
    т
    р
    а
    extension -- П
    р
    о
    т
    я
    ж
    е
    н
    н
    о
    с
    т
    ь
    в
    м
    е
    т
    р
    а
    х
    с
    о
    к
    р
    у
    г
    л
    е
    н
    и
    е
    м
    д
    о
    1
    м
    е
    т
    р
    а
    depth -- Г
    л
    у
    б
    и
    н
    а
    в
    м
    е
    т
    р
    а
    х
    с
    о
    к
    р
    у
    г
    л
    е
    н
    и
    е
    м
    д
    о
    0,1
    м
    е
    т
    р
    а
    occurence_depth -- Г
    л
    у
    б
    и
    н
    а
    з
    а
    л
    е
    г
    а
    н
    и
    я
    в
    м
    е
    т
    р
    а
    х
    с
    о
    к
    р
    у
    г
    л
    е
    н
    и
    е
    м
    д
    о
    0,1
    м
    е
    т
    р
    а
    volume -- О
    б
    ъ
    е
    м
    в
    к
    у
    б
    и
    ч
    е
    с
    к
    и
    х
    м
    е
    т
    р
    а
    х
    с
    о
    к
    р
    у
    г
    л
    е
    н
    и
    е
    м
    д
    о
    1
    к
    у
    б
    и
    ч
    е
    с
    к
    о
    г
    о
    м
    е
    т
    р
    а
    height -- В
    ы
    с
    о
    т
    а
    в
    м
    е
    т
    р
    а
    х
    с
    о
    к
    р
    у
    г
    л
    е
    н
    и
    е
    м
    д
    о
    0,1
    м
    е
    т
    р
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, area=None, built_up_area=None, extension=None, depth=None, occurence_depth=None, volume=None, height=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.area = area
        self.validate_PositiveDecimal(self.area)
        self.area_nsprefix_ = None
        self.built_up_area = built_up_area
        self.validate_PositiveDecimal(self.built_up_area)
        self.built_up_area_nsprefix_ = None
        self.extension = extension
        self.validate_PositiveDecimal(self.extension)
        self.extension_nsprefix_ = None
        self.depth = depth
        self.validate_PositiveDecimal(self.depth)
        self.depth_nsprefix_ = None
        self.occurence_depth = occurence_depth
        self.validate_PositiveDecimal(self.occurence_depth)
        self.occurence_depth_nsprefix_ = None
        self.volume = volume
        self.validate_PositiveDecimal(self.volume)
        self.volume_nsprefix_ = None
        self.height = height
        self.validate_PositiveDecimal(self.height)
        self.height_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, base_parameterType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if base_parameterType.subclass:
            return base_parameterType.subclass(*args_, **kwargs_)
        else:
            return base_parameterType(*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_area(self):
        return self.area
    def set_area(self, area):
        self.area = area
    def get_built_up_area(self):
        return self.built_up_area
    def set_built_up_area(self, built_up_area):
        self.built_up_area = built_up_area
    def get_extension(self):
        return self.extension
    def set_extension(self, extension):
        self.extension = extension
    def get_depth(self):
        return self.depth
    def set_depth(self, depth):
        self.depth = depth
    def get_occurence_depth(self):
        return self.occurence_depth
    def set_occurence_depth(self, occurence_depth):
        self.occurence_depth = occurence_depth
    def get_volume(self):
        return self.volume
    def set_volume(self, volume):
        self.volume = volume
    def get_height(self):
        return self.height
    def set_height(self, height):
        self.height = height
    def validate_PositiveDecimal(self, value):
        result = True
        # Validate type PositiveDecimal, a restriction on xs:decimal.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if value <= 0:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minExclusive restriction on PositiveDecimal' % {"value": value, "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.area is not None or
            self.built_up_area is not None or
            self.extension is not None or
            self.depth is not None or
            self.occurence_depth is not None or
            self.volume is not None or
            self.height is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='base_parameterType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('base_parameterType')
        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_ == 'base_parameterType':
            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_='base_parameterType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='base_parameterType', 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_='base_parameterType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='base_parameterType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.area is not None:
            namespaceprefix_ = self.area_nsprefix_ + ':' if (UseCapturedNS_ and self.area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sarea>%s</%sarea>%s' % (namespaceprefix_ , self.gds_format_decimal(self.area, input_name='area'), namespaceprefix_ , eol_))
        if self.built_up_area is not None:
            namespaceprefix_ = self.built_up_area_nsprefix_ + ':' if (UseCapturedNS_ and self.built_up_area_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sbuilt_up_area>%s</%sbuilt_up_area>%s' % (namespaceprefix_ , self.gds_format_decimal(self.built_up_area, input_name='built_up_area'), namespaceprefix_ , eol_))
        if self.extension is not None:
            namespaceprefix_ = self.extension_nsprefix_ + ':' if (UseCapturedNS_ and self.extension_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sextension>%s</%sextension>%s' % (namespaceprefix_ , self.gds_format_decimal(self.extension, input_name='extension'), namespaceprefix_ , eol_))
        if self.depth is not None:
            namespaceprefix_ = self.depth_nsprefix_ + ':' if (UseCapturedNS_ and self.depth_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdepth>%s</%sdepth>%s' % (namespaceprefix_ , self.gds_format_decimal(self.depth, input_name='depth'), namespaceprefix_ , eol_))
        if self.occurence_depth is not None:
            namespaceprefix_ = self.occurence_depth_nsprefix_ + ':' if (UseCapturedNS_ and self.occurence_depth_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%soccurence_depth>%s</%soccurence_depth>%s' % (namespaceprefix_ , self.gds_format_decimal(self.occurence_depth, input_name='occurence_depth'), namespaceprefix_ , eol_))
        if self.volume is not None:
            namespaceprefix_ = self.volume_nsprefix_ + ':' if (UseCapturedNS_ and self.volume_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%svolume>%s</%svolume>%s' % (namespaceprefix_ , self.gds_format_decimal(self.volume, input_name='volume'), namespaceprefix_ , eol_))
        if self.height is not None:
            namespaceprefix_ = self.height_nsprefix_ + ':' if (UseCapturedNS_ and self.height_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sheight>%s</%sheight>%s' % (namespaceprefix_ , self.gds_format_decimal(self.height, input_name='height'), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'area')
            fval_ = self.gds_validate_decimal(fval_, node, 'area')
            self.area = fval_
            self.area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.area)
        elif nodeName_ == 'built_up_area' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'built_up_area')
            fval_ = self.gds_validate_decimal(fval_, node, 'built_up_area')
            self.built_up_area = fval_
            self.built_up_area_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.built_up_area)
        elif nodeName_ == 'extension' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'extension')
            fval_ = self.gds_validate_decimal(fval_, node, 'extension')
            self.extension = fval_
            self.extension_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.extension)
        elif nodeName_ == 'depth' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'depth')
            fval_ = self.gds_validate_decimal(fval_, node, 'depth')
            self.depth = fval_
            self.depth_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.depth)
        elif nodeName_ == 'occurence_depth' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'occurence_depth')
            fval_ = self.gds_validate_decimal(fval_, node, 'occurence_depth')
            self.occurence_depth = fval_
            self.occurence_depth_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.occurence_depth)
        elif nodeName_ == 'volume' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'volume')
            fval_ = self.gds_validate_decimal(fval_, node, 'volume')
            self.volume = fval_
            self.volume_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.volume)
        elif nodeName_ == 'height' and child_.text:
            sval_ = child_.text
            fval_ = self.gds_parse_decimal(sval_, node, 'height')
            fval_ = self.gds_validate_decimal(fval_, node, 'height')
            self.height = fval_
            self.height_nsprefix_ = child_.prefix
            # validate type PositiveDecimal
            self.validate_PositiveDecimal(self.height)
# end class base_parameterType


class partnership_participantsType(GeneratedsSuper):
    """partnership_participantsType -- У
    ч
    а
    с
    т
    н
    и
    к
    и
    д
    о
    г
    о
    в
    о
    р
    а
    и
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    о
    г
    о
    т
    о
    в
    а
    р
    и
    щ
    е
    с
    т
    в
    а
    partnership_participant -- У
    ч
    а
    с
    т
    н
    и
    к
    д
    о
    г
    о
    в
    о
    р
    а
    и
    н
    в
    е
    с
    т
    и
    ц
    и
    о
    н
    н
    о
    г
    о
    т
    о
    в
    а
    р
    и
    щ
    е
    с
    т
    в
    а
    Т
    и
    п
    и
    н
    о
    г
    о
    с
    у
    б
    ъ
    е
    к
    т
    а
    п
    р
    а
    в
    а
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, partnership_participant=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 partnership_participant is None:
            self.partnership_participant = []
        else:
            self.partnership_participant = partnership_participant
        self.partnership_participant_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, partnership_participantsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if partnership_participantsType.subclass:
            return partnership_participantsType.subclass(*args_, **kwargs_)
        else:
            return partnership_participantsType(*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_partnership_participant(self):
        return self.partnership_participant
    def set_partnership_participant(self, partnership_participant):
        self.partnership_participant = partnership_participant
    def add_partnership_participant(self, value):
        self.partnership_participant.append(value)
    def insert_partnership_participant_at(self, index, value):
        self.partnership_participant.insert(index, value)
    def replace_partnership_participant_at(self, index, value):
        self.partnership_participant[index] = value
    def has__content(self):
        if (
            self.partnership_participant
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='partnership_participantsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('partnership_participantsType')
        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_ == 'partnership_participantsType':
            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_='partnership_participantsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='partnership_participantsType', 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_='partnership_participantsType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='partnership_participantsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for partnership_participant_ in self.partnership_participant:
            namespaceprefix_ = self.partnership_participant_nsprefix_ + ':' if (UseCapturedNS_ and self.partnership_participant_nsprefix_) else ''
            partnership_participant_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='partnership_participant', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'partnership_participant':
            obj_ = PartnershipParticipant.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.partnership_participant.append(obj_)
            obj_.original_tagname_ = 'partnership_participant'
# end class partnership_participantsType


class addressType(GeneratedsSuper):
    """addressType -- А
    д
    р
    е
    с
    (
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    е
    )
    note -- Н
    е
    ф
    о
    р
    м
    а
    л
    и
    з
    о
    в
    а
    н
    н
    о
    е
    о
    п
    и
    с
    а
    н
    и
    е
    м
    е
    с
    т
    о
    п
    о
    л
    о
    ж
    е
    н
    и
    я
    readable_address -- А
    д
    р
    е
    с
    в
    с
    о
    о
    т
    в
    е
    т
    с
    т
    в
    и
    и
    с
    Ф
    И
    А
    С
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, note=None, readable_address=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.note = note
        self.note_nsprefix_ = None
        self.readable_address = readable_address
        self.validate_MultiLiner(self.readable_address)
        self.readable_address_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, addressType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if addressType.subclass:
            return addressType.subclass(*args_, **kwargs_)
        else:
            return addressType(*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_note(self):
        return self.note
    def set_note(self, note):
        self.note = note
    def get_readable_address(self):
        return self.readable_address
    def set_readable_address(self, readable_address):
        self.readable_address = readable_address
    def validate_MultiLiner(self, value):
        result = True
        # Validate type MultiLiner, a restriction on xs:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            pass
        return result
    def has__content(self):
        if (
            self.note is not None or
            self.readable_address is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='addressType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('addressType')
        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_ == 'addressType':
            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_='addressType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='addressType', 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_='addressType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='addressType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.note is not None:
            namespaceprefix_ = self.note_nsprefix_ + ':' if (UseCapturedNS_ and self.note_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snote>%s</%snote>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.note), input_name='note')), namespaceprefix_ , eol_))
        if self.readable_address is not None:
            namespaceprefix_ = self.readable_address_nsprefix_ + ':' if (UseCapturedNS_ and self.readable_address_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sreadable_address>%s</%sreadable_address>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.readable_address), input_name='readable_address')), 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'note':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'note')
            value_ = self.gds_validate_string(value_, node, 'note')
            self.note = value_
            self.note_nsprefix_ = child_.prefix
        elif nodeName_ == 'readable_address':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'readable_address')
            value_ = self.gds_validate_string(value_, node, 'readable_address')
            self.readable_address = value_
            self.readable_address_nsprefix_ = child_.prefix
            # validate type MultiLiner
            self.validate_MultiLiner(self.readable_address)
# end class addressType


class right_numbersType(GeneratedsSuper):
    """right_numbersType -- З
    а
    р
    е
    г
    и
    с
    т
    р
    о
    в
    а
    н
    н
    ы
    е
    п
    р
    а
    в
    а
    right_number -- З
    а
    р
    е
    г
    и
    с
    т
    р
    и
    р
    о
    в
    а
    н
    н
    о
    е
    п
    р
    а
    в
    о
    
    """
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, right_number=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 right_number is None:
            self.right_number = []
        else:
            self.right_number = right_number
        self.right_number_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, right_numbersType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if right_numbersType.subclass:
            return right_numbersType.subclass(*args_, **kwargs_)
        else:
            return right_numbersType(*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_right_number(self):
        return self.right_number
    def set_right_number(self, right_number):
        self.right_number = right_number
    def add_right_number(self, value):
        self.right_number.append(value)
    def insert_right_number_at(self, index, value):
        self.right_number.insert(index, value)
    def replace_right_number_at(self, index, value):
        self.right_number[index] = value
    def has__content(self):
        if (
            self.right_number
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_numbersType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('right_numbersType')
        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_ == 'right_numbersType':
            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_='right_numbersType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='right_numbersType', 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_='right_numbersType'):
        pass
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='right_numbersType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for right_number_ in self.right_number:
            namespaceprefix_ = self.right_number_nsprefix_ + ':' if (UseCapturedNS_ and self.right_number_nsprefix_) else ''
            right_number_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='right_number', 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):
        pass
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'right_number':
            obj_ = RegisteredRight.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.right_number.append(obj_)
            obj_.original_tagname_ = 'right_number'
# end class right_numbersType


GDSClassesMapping = {
    'extract_cadastral_plan_territory': ExtractCadastralPlanTerritory,
}


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 = 'ExtractCadastralPlanTerritory'
        rootClass = ExtractCadastralPlanTerritory
    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 = 'ExtractCadastralPlanTerritory'
        rootClass = ExtractCadastralPlanTerritory
    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 = 'ExtractCadastralPlanTerritory'
        rootClass = ExtractCadastralPlanTerritory
    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 = 'ExtractCadastralPlanTerritory'
        rootClass = ExtractCadastralPlanTerritory
    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 kpt_11 import *\n\n')
        sys.stdout.write('import kpt_11 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_ = {}

__all__ = [
    "AdditionalContourLocationOut",
    "AdditionalEncumbranceInfoType",
    "Address",
    "AddressCity",
    "AddressLocationBuild",
    "AddressLocationCarParkingSpace",
    "AddressLocationConstruction",
    "AddressLocationLand",
    "AddressLocationPropertyComplex",
    "AddressLocationRefPoint",
    "AddressLocationRoom",
    "AddressLocationText",
    "AddressMain",
    "AddressOksLocation",
    "AddressRoom",
    "AddressText",
    "AllowedUse",
    "AnotherGuarantor",
    "AnotherGuarantors",
    "AnotherRestricted",
    "AnotherRight",
    "AnotherTypeRestricted",
    "AnotherTypeRight",
    "AparthouseOwners",
    "Apartment",
    "ApartmentBuilding",
    "ApartmentBuildingUse",
    "ApprovePersons",
    "Area",
    "AreaContours",
    "AreaQuarter",
    "AreaValue",
    "AscendantCadNumbers",
    "BaseData",
    "BaseDataNotice",
    "BaseDataRightRestrictIndivid",
    "BaseDataType",
    "BaseParameters",
    "BasisHiredHouse",
    "Bobject",
    "BobjectCoastline",
    "BobjectMunicipalInhabitedBoundary",
    "BobjectSubjectBoundary",
    "BobjectSurveyingProject",
    "BobjectZonesAndTerritories",
    "BondsHoldersOut",
    "Border",
    "BorderlandDisput",
    "Borders",
    "BoundContourOut",
    "BoundContoursLocationOut",
    "BoundContoursOut",
    "BuildPartProperty",
    "BuildPartsProperty",
    "BuildRecord",
    "BuildRecordsContoursAdditional",
    "BuildRecordsContoursLocation",
    "BuilderShare",
    "BuilderShareWithObject",
    "CadLinkRestrictions",
    "CadLinks",
    "CadLinksAll",
    "CadLinksCarParkingSpace",
    "CadLinksCarParkingSpaceBase",
    "CadLinksComplex",
    "CadLinksLandAll",
    "CadLinksLandIncludedOld",
    "CadLinksLandOld",
    "CadLinksRealEstateAbout",
    "CadLinksRealEstateBase",
    "CadLinksRoom",
    "CadLinksRoomAll",
    "CadLinksUnderConstruction",
    "CadNumber",
    "CadWork",
    "CadWorkOut",
    "CadWorks",
    "CadWorksOut",
    "CadastralBlock",
    "CadastralBlocks",
    "CadastralNumbsAdjacentParcels",
    "CancelDate",
    "CarParkingPlaceCadNumbers",
    "CarParkingSpaceLocationInBuild",
    "CarParkingSpaceLocationInBuildPlans",
    "CarParkingSpaceRecord",
    "CertificatesHoldersOut",
    "Changes",
    "CharacterPointDistance",
    "CharacterPointDistances",
    "Citizenship",
    "City",
    "ClaimAssignmentMark",
    "ClaimAssignmentMarks",
    "ClaimDataOut",
    "ClaimDataOutAll",
    "ClaimRecordOut",
    "ClaimRecordsOut",
    "ClaimRecordsOutAll",
    "ClaimRecordsOutType",
    "CoastlineBoundariesType",
    "CommonData",
    "CommonDataAll",
    "CommonDataType",
    "CommonLand",
    "CommonLandCadNumber",
    "CommonLandCadNumbers",
    "ConstructionPartProperty",
    "ConstructionPartsProperty",
    "ConstructionRecord",
    "ConstructionRecordsContoursAdditional",
    "ConstructionRecordsContoursLocation",
    "Contacts",
    "ContentRestrictions",
    "ContourAreaZU",
    "ContourOKSOut",
    "ContourZUOut",
    "ContourZUZacrep",
    "ContoursAreaZU",
    "ContoursLocationAdditionalOKSOut",
    "ContoursLocationBorders",
    "ContoursLocationOKSOut",
    "ContoursLocationZUOut",
    "ContoursLocationZUZacrep",
    "ContoursOKSOut",
    "ContoursZUOut",
    "ContoursZUZacrep",
    "Contract",
    "Contractors",
    "Cost",
    "CostAllType",
    "CostInfo",
    "CostValue",
    "CourtDecisionOut",
    "CulturalHeritage",
    "DataObject",
    "DataObjectBuild",
    "DataObjectCarParkingSpace",
    "DataObjectConstruction",
    "DataObjectLand",
    "DataObjectPropertyComplex",
    "DataObjectRoom",
    "DateRemovedCadAccount",
    "DatesChanges",
    "DealDataShareHoldings",
    "DealDataType",
    "DealParties",
    "DealParty",
    "DealRecordNumber",
    "DealRecordShareHoldings",
    "DealRecordType",
    "DealRecordsShareHoldings",
    "DealRecordsType",
    "DealRegistered",
    "DecisionRequisites",
    "DescendantCadNumbers",
    "DetailedLevel",
    "DetailsRequest",
    "DetailsRequestPeriod",
    "DetailsStatement",
    "DetailsStatementRealty",
    "Dict",
    "DissentingEntities",
    "District",
    "DocNotarized",
    "DocRequisite",
    "DocRequisiteMain",
    "DocRequisites",
    "DocumentRequisiteBase",
    "DocumentRequisites",
    "DocumentType",
    "DocumentsType",
    "EliminationType",
    "Enforcement",
    "EntityOut",
    "EntitySpatialBound",
    "EntitySpatialOKSOut",
    "EntitySpatialZUOut",
    "EntitySpatialZUZacrep",
    "EntityUL",
    "EquityParticipantsInfo",
    "ExpropriationInfo",
    "ExtractCadastralPlanTerritory",
    "Fio",
    "ForeignPublic",
    "Forest",
    "ForestQuarter",
    "ForestQuarters",
    "Forests",
    "FormLandStateNotDifferenntiated",
    "FormLandWithdrawalAndNotDifferenntiated",
    "FormingParcelNumberContours",
    "FormingParcelsNumberContours",
    "GovementEntity",
    "GovernmentLandSupervision",
    "Guarantee",
    "GuardedNaturalBoundaries",
    "HoldersRelatedLands",
    "HouseDescription",
    "HouseDescriptions",
    "IdentifiedViolations",
    "IncapacityIndividual",
    "IncapacityInfo",
    "IncapacityInfoType",
    "IncludedCadNumbers",
    "IncludedObjects",
    "IncludedParcels",
    "IncludedParcelsInZone",
    "IndividualFull",
    "IndividualOut",
    "Infant",
    "InfoObjects",
    "InformationFund",
    "InhabitedLocalityBoundariesType",
    "Insurance",
    "IntersectionCadNumbers",
    "IntersectionOrdinate",
    "IntersectionPoint",
    "IntersectionPoints",
    "InvestmentUnitOwnerOut",
    "LandArea",
    "LandCadNumbers",
    "LandDisput",
    "LandPartProperty",
    "LandPartsProperty",
    "LandRecord",
    "LandRecordApartmentBuilding",
    "LandRecordsContoursLocation",
    "Law",
    "LegalEntityOut",
    "LegalEntityUL",
    "Level",
    "Level1",
    "Level2",
    "Level3",
    "LevelAll",
    "LimitDimensions",
    "Litigations",
    "LitigationsContent",
    "Locality",
    "LocationByARefPoint",
    "LocationCity",
    "LocationInBuild",
    "LocationInBuildContours",
    "LocationLevelsContours",
    "LocationOks",
    "LocationsCity",
    "MarkContent",
    "MarkOrdinate",
    "Material",
    "Materials",
    "MunicipalBoundariesType",
    "Municipality",
    "Name",
    "NaturalObjects",
    "NeighbourRegion",
    "NeighbourRegions",
    "NewAroseRightNumbers",
    "NoCitizenshipPerson",
    "NonRegistrability",
    "NonRegistrabilitys",
    "NotEquityParticipantsInfo",
    "NotResidentOut",
    "Note",
    "OMSPoint",
    "OMSPoints",
    "ObjectAndWithdrawalState",
    "ObjectCadNumber",
    "ObjectCommonData",
    "ObjectLand",
    "ObjectLandAndWithdrawal",
    "ObjectPartNumberDate",
    "ObjectPartNumberRestrictions",
    "ObjectPartsAreaRestrictions",
    "ObjectPartsNumberRestrictions",
    "ObjectSubType",
    "ObjectType",
    "ObjectUnderConstructionRecord",
    "Objections",
    "OldNumber",
    "OldNumbers",
    "OrdinateBound",
    "OrdinateOKSOut",
    "OrdinateZUOut",
    "OrdinateZacrep",
    "OrdinatesBound",
    "OrdinatesOKSOut",
    "OrdinatesZUOut",
    "OrdinatesZacrep",
    "OriginContent",
    "OtherNaturalObject",
    "OtherNaturalObjects",
    "OtherSubject",
    "OwnerlessRight",
    "OwnerlessRightRecordOut",
    "ParamsBuildAboutType",
    "ParamsBuildPurposeUses",
    "ParamsBuildWithoutMaterials",
    "ParamsCarParkingSpaceObject",
    "ParamsComplex",
    "ParamsConstructionAll",
    "ParamsConstructionPurpose",
    "ParamsConstructionPurposeUses",
    "ParamsLandCategoryUses",
    "ParamsLandUses",
    "ParamsPurpose",
    "ParamsRoomBase",
    "ParamsRoomBaseWithoutName",
    "ParamsRoomObject",
    "ParamsRoomWithoutSpecialType",
    "ParamsUnderConstructionDegree",
    "PartNumber",
    "PartNumbers",
    "Partnership",
    "PartnershipParticipant",
    "PeriodDDU",
    "PeriodInfoType",
    "PeriodStartEnd",
    "PeriodStartEndAvailable",
    "PeriodType",
    "PeriodTypeLand",
    "PermittedAncillaries",
    "PermittedAncillary",
    "PermittedConditionallyUses",
    "PermittedPrimary",
    "PermittedPrimaryUses",
    "PermittedUse",
    "PermittedUseEstablished",
    "PermittedUses",
    "PermittesUsesGradReg",
    "PersonCitizenshipCountry",
    "PersonDocument",
    "PersonalParticipations",
    "Plan",
    "Plans",
    "PropertyComplexRecord",
    "PropertyComplexRecordParams",
    "PublicFormationType",
    "PublicFormations",
    "PublicServitude",
    "RecordData",
    "RecordInfo",
    "RecordInfoAllDates",
    "RecordInfoDate",
    "RegNumbBorder",
    "RegNumberBorder",
    "RegNumberBorderZone",
    "RegisteredRight",
    "Registration",
    "RegistrationDate",
    "ReinstatementDate",
    "Representative",
    "RepresentativeKind",
    "ResidentOut",
    "RestrictParties",
    "RestrictRecordLandType",
    "RestrictRecordMain",
    "RestrictRecordNumber",
    "RestrictRecordType",
    "RestrictRecordsBaseParams",
    "RestrictRecordsBaseParamsLand",
    "RestrictRecordsIndivid",
    "RestrictRecordsIndividNoPart",
    "RestrictRecordsMain",
    "RestrictedRightsPartiesOut",
    "RestrictedRightsPartyOut",
    "RestrictingDealsAllNumber",
    "RestrictingRights",
    "RestrictingRightsAllNumber",
    "RestrictionsEncumbrances",
    "RestrictionsEncumbrancesData",
    "RestrictionsEncumbrancesDataLand",
    "RestrictionsEncumbrancesDataPart",
    "RestrictionsEncumbrancesNoPart",
    "ResultsEvent",
    "RightData",
    "RightDataAndCancel",
    "RightDataReinstatement",
    "RightHolderOut",
    "RightHoldersOut",
    "RightNumber",
    "RightRecordIndivid",
    "RightRecordNumber",
    "RightRecordsAboutProperty",
    "RightRecordsBaseParams",
    "RightRecordsLitigationsObjections",
    "RightRecordsTransfer",
    "RoomCadNumbers",
    "RoomCharacterPoint",
    "RoomCharacterPoints",
    "RoomDescription",
    "RoomDescriptions",
    "RoomLocation",
    "RoomLocationInBuild",
    "RoomLocationInBuildPlans",
    "RoomOwnersShare",
    "RoomPartProperty",
    "RoomPartsProperty",
    "RoomRecord",
    "Russia",
    "ServitudeType",
    "Share",
    "ShareBalHectare",
    "ShareHectare",
    "ShareSubjectDescription",
    "ShareUnknown",
    "Shares",
    "SovietVillage",
    "SpatialDataType",
    "SpatialElementBound",
    "SpatialElementOKSOut",
    "SpatialElementZacrep",
    "SpatialsElementZUOut",
    "SpatialsElementsBound",
    "SpatialsElementsOKSOut",
    "SpatialsElementsZUOut",
    "SpatialsElementsZacrep",
    "SpecialEconomicBoundary",
    "SpecialUseBoundaries",
    "SpecificLocation",
    "SpecificMark",
    "SpecificMarkDistance",
    "SpecificMarkDistances",
    "SpecificMarkLocation",
    "SpecificMarks",
    "StateExpropriation",
    "Street",
    "Subject",
    "SubjectBoundariesType",
    "SubjectOfRF",
    "SubjectRestricted",
    "SupervisionEvent",
    "SupervisionEvents",
    "SurveyBoundaries",
    "SurveyingProjectType",
    "ThirdPartyConsent",
    "ThirdPartyConsents",
    "Undefined",
    "UnderlyingDocumentOut",
    "UnderlyingDocumentOutAll",
    "UnderlyingDocumentsMain",
    "UnderlyingDocumentsOut",
    "UnderlyingDocumentsOutAll",
    "UnderlyingDocumentsRequisites",
    "UnifiedRealEstateComplexRecord",
    "UnionState",
    "UnitedCadNumbers",
    "UrbanDistrict",
    "Water",
    "Waters",
    "WithdrawalStateMunicNeeds",
    "ZonePermittedUses",
    "ZonesAndBoundaries",
    "ZonesAndTerritoriesBoundariesType",
    "actType",
    "additional_encumbrance_infoType",
    "addressType",
    "approve_personType",
    "base_parameterType",
    "build_recordType",
    "build_recordsType",
    "build_recordsType12",
    "car_parking_space_recordType",
    "car_parking_space_recordsType",
    "categoryType",
    "claim_dataType",
    "claim_recordType",
    "claim_recordType6",
    "coastline_recordType",
    "common_land_partsType",
    "construction_recordType",
    "construction_recordsType",
    "construction_recordsType13",
    "contoursType",
    "decision_ownerType",
    "dissenting_entityType",
    "forestType",
    "forest_quartersType",
    "group_lower_requisitesType",
    "group_lower_requisitesType2",
    "group_top_requisitesType",
    "group_top_requisitesType1",
    "heritage_decisionsType",
    "inhabited_locality_boundary_recordType",
    "land_recordType",
    "land_recordsType",
    "land_recordsType11",
    "ligitation_infoType",
    "litigationType",
    "litigationType7",
    "municipal_boundary_recordType",
    "object_partType",
    "object_under_construction_recordType",
    "object_under_construction_recordsType",
    "object_under_construction_recordsType14",
    "objectionType",
    "partnership_participantsType",
    "periodType",
    "period_infoType",
    "personal_participationType",
    "planType",
    "plansType",
    "property_complex_recordsType",
    "restrict_recordType",
    "restrict_recordType9",
    "restriction_encumbranceType",
    "restriction_encumbranceType8",
    "restrictions_encumbrances_dataType",
    "restrictions_encumbrances_dataType10",
    "right_numbersType",
    "right_recordType",
    "right_recordType3",
    "right_recordType4",
    "right_recordType5",
    "right_record_numbersType",
    "room_recordType",
    "room_recordsType",
    "servitudeType",
    "subject_boundary_recordType",
    "surveying_project_recordType",
    "unified_real_estate_complex_recordsType",
    "zones_and_territories_recordType"
]
