# copyright 2016 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
# contact http://www.logilab.fr -- mailto:contact@logilab.fr
#
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 2.1 of the License, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
"""THIS FILE IS GENERATED FROM SEDA 2.0 XSD FILES, DO NOT EDIT"""

from cubicweb.web import formwidgets as fw
from cubicweb.web.views import uicfg

ives = uicfg.indexview_etype_section
ives['SEDALastModified'] = 'subobject'
ives['SEDADataObjectVersion'] = 'subobject'
ives['SEDAReplaces'] = 'subobject'
ives['SEDAAltReferencesArchiveUnitRefId'] = 'subobject'
ives['SEDACreatingOsVersion'] = 'subobject'
ives['SEDARepositoryArchiveUnitPID'] = 'subobject'
ives['SEDAKeywordReference'] = 'subobject'
ives['SEDASignature'] = 'subobject'
ives['SEDASpatial'] = 'subobject'
ives['SEDAMessageDigestAlgorithmCodeListVersion'] = 'subobject'
ives['SEDAFormatLitteral'] = 'subobject'
ives['SEDADateCreatedByApplication'] = 'subobject'
ives['SEDAFormatId'] = 'subobject'
ives['SEDAOriginatingAgencyArchiveUnitIdentifier'] = 'subobject'
ives['SEDAAltClassificationRulePreventInheritance'] = 'subobject'
ives['SEDAGpsAltitudeRef'] = 'subobject'
ives['SEDAAltIsVersionOfArchiveUnitRefId'] = 'subobject'
ives['SEDAArchiveUnitRefId'] = 'subobject'
ives['SEDAHeight'] = 'subobject'
ives['SEDASentDate'] = 'subobject'
ives['SEDAGpsLongitude'] = 'subobject'
ives['SEDALanguage'] = 'subobject'
ives['SEDAClassificationReassessingDate'] = 'subobject'
ives['SEDAGpsLatitude'] = 'subobject'
ives['SEDADiameter'] = 'subobject'
ives['SEDACustodialHistoryFile'] = 'subobject'
ives['SEDAStatus'] = 'subobject'
ives['SEDASeqStorageRuleRule'] = 'subobject'
ives['SEDAAltReplacesArchiveUnitRefId'] = 'subobject'
ives['SEDASystemId'] = 'subobject'
ives['SEDAEventType'] = 'subobject'
ives['SEDAIsPartOf'] = 'subobject'
ives['SEDAPreventInheritance'] = 'subobject'
ives['SEDAAltArchiveUnitArchiveUnitRefId'] = 'subobject'
ives['SEDAwhen'] = 'subobject'
ives['SEDAKeywordType'] = 'subobject'
ives['SEDAGpsAltitude'] = 'subobject'
ives['SEDAIsVersionOf'] = 'subobject'
ives['SEDAArchivalAgreement'] = 'subobject'
ives['SEDAFileFormatCodeListVersion'] = 'subobject'
ives['SEDASeqAltArchiveUnitArchiveUnitRefIdManagement'] = 'subobject'
ives['SEDATitle'] = 'subobject'
ives['SEDAGpsDateStamp'] = 'subobject'
ives['SEDAEncoding'] = 'subobject'
ives['SEDACreatingApplicationVersion'] = 'subobject'
ives['SEDATransactedDate'] = 'subobject'
ives['SEDARepositoryObjectPID'] = 'subobject'
ives['SEDARegisteredDate'] = 'subobject'
ives['SEDANeedAuthorization'] = 'subobject'
ives['SEDAEvent'] = 'subobject'
ives['SEDARelationship'] = 'subobject'
ives['SEDATag'] = 'subobject'
ives['SEDAAltStorageRulePreventInheritance'] = 'subobject'
ives['SEDAWriter'] = 'subobject'
ives['SEDAAccessRuleCodeListVersion'] = 'subobject'
ives['SEDAAcquisitionInformationCodeListVersion'] = 'subobject'
ives['SEDALegalStatus'] = 'subobject'
ives['SEDADisseminationRule'] = 'subobject'
ives['SEDAAddressee'] = 'subobject'
ives['SEDAReferences'] = 'subobject'
ives['SEDADataObjectVersionCodeListVersion'] = 'subobject'
ives['SEDAAuthorizedAgent'] = 'subobject'
ives['SEDASubmissionAgencyIdentifier'] = 'subobject'
ives['SEDACreatingApplicationName'] = 'subobject'
ives['SEDAKeyword'] = 'subobject'
ives['SEDADescription'] = 'subobject'
ives['SEDAFilePlanPosition'] = 'subobject'
ives['SEDAArchiveUnit'] = 'subobject'
ives['SEDASeqAccessRuleRule'] = 'subobject'
ives['SEDARefNonRuleId'] = 'subobject'
ives['SEDAWidth'] = 'subobject'
ives['SEDAClassificationRuleCodeListVersion'] = 'subobject'
ives['SEDARequires'] = 'subobject'
ives['SEDAOriginatingSystemId'] = 'subobject'
ives['SEDAVersion'] = 'subobject'
ives['SEDAGpsLongitudeRef'] = 'subobject'
ives['SEDASource'] = 'subobject'
ives['SEDAAcquisitionInformation'] = 'subobject'
ives['SEDAEndDate'] = 'subobject'
ives['SEDACreatingOs'] = 'subobject'
ives['SEDAAltRequiresArchiveUnitRefId'] = 'subobject'
ives['SEDAWeight'] = 'subobject'
ives['SEDAType'] = 'subobject'
ives['SEDADocumentType'] = 'subobject'
ives['SEDAGpsLatitudeRef'] = 'subobject'
ives['SEDAComment'] = 'subobject'
ives['SEDADescriptionLanguage'] = 'subobject'
ives['SEDAAccessRule'] = 'subobject'
ives['SEDACompressionAlgorithmCodeListVersion'] = 'subobject'
ives['SEDATemporal'] = 'subobject'
ives['SEDAPhysicalDataObject'] = 'subobject'
ives['SEDAStartDate'] = 'subobject'
ives['SEDAThickness'] = 'subobject'
ives['SEDAAltAppraisalRulePreventInheritance'] = 'subobject'
ives['SEDASeqAppraisalRuleRule'] = 'subobject'
ives['SEDAEncodingCodeListVersion'] = 'subobject'
ives['SEDATransferRequestReplyIdentifier'] = 'subobject'
ives['SEDARelationshipCodeListVersion'] = 'subobject'
ives['SEDACompressed'] = 'subobject'
ives['SEDAUri'] = 'subobject'
ives['SEDAEventDetail'] = 'subobject'
ives['SEDAAppraisalRule'] = 'subobject'
ives['SEDAReuseRuleCodeListVersion'] = 'subobject'
ives['SEDAAcquiredDate'] = 'subobject'
ives['SEDASeqReuseRuleRule'] = 'subobject'
ives['SEDAServiceLevel'] = 'subobject'
ives['SEDANumberOfPage'] = 'subobject'
ives['SEDAAppraisalRuleCodeListVersion'] = 'subobject'
ives['SEDAJuridictional'] = 'subobject'
ives['SEDAReuseRule'] = 'subobject'
ives['SEDACustodialHistoryItem'] = 'subobject'
ives['SEDATransferringAgencyArchiveUnitIdentifier'] = 'subobject'
ives['SEDALength'] = 'subobject'
ives['SEDAArchivalAgencyArchiveUnitIdentifier'] = 'subobject'
ives['SEDAOriginatingAgency'] = 'subobject'
ives['SEDACreatedDate'] = 'subobject'
ives['SEDADisseminationRuleCodeListVersion'] = 'subobject'
ives['SEDAAltAccessRulePreventInheritance'] = 'subobject'
ives['SEDADepth'] = 'subobject'
ives['SEDAEventIdentifier'] = 'subobject'
ives['SEDAAltBinaryDataObjectAttachment'] = 'subobject'
ives['SEDANeedReassessingAuthorization'] = 'subobject'
ives['SEDAStorageRule'] = 'subobject'
ives['SEDABinaryDataObject'] = 'subobject'
ives['SEDAGpsVersionID'] = 'subobject'
ives['SEDASeqDisseminationRuleRule'] = 'subobject'
ives['SEDAAltReuseRulePreventInheritance'] = 'subobject'
ives['SEDAClassificationRule'] = 'subobject'
ives['SEDARelatedTransferReference'] = 'subobject'
ives['SEDAAttachment'] = 'subobject'
ives['SEDASeqClassificationRuleRule'] = 'subobject'
ives['SEDAStorageRuleCodeListVersion'] = 'subobject'
ives['SEDASubmissionAgency'] = 'subobject'
ives['SEDAMimeType'] = 'subobject'
ives['SEDAReceivedDate'] = 'subobject'
ives['SEDAOriginatingAgencyIdentifier'] = 'subobject'
ives['SEDAMimeTypeCodeListVersion'] = 'subobject'
ives['SEDARecipient'] = 'subobject'
ives['SEDADataObjectReference'] = 'subobject'
ives['SEDAAltDisseminationRulePreventInheritance'] = 'subobject'
ives['SEDAShape'] = 'subobject'
ives['SEDAAltIsPartOfArchiveUnitRefId'] = 'subobject'


abaa = uicfg.actionbox_appearsin_addmenu
abaa.tag_subject_of(('*', 'seda_comment', '*'), False)
abaa.tag_object_of(('*', 'seda_comment', '*'), False)
abaa.tag_subject_of(('*', 'seda_signature', '*'), False)
abaa.tag_object_of(('*', 'seda_signature', '*'), False)
abaa.tag_subject_of(('*', 'seda_archival_agreement', '*'), False)
abaa.tag_object_of(('*', 'seda_archival_agreement', '*'), False)
abaa.tag_subject_of(('*', 'seda_related_transfer_reference', '*'), False)
abaa.tag_object_of(('*', 'seda_related_transfer_reference', '*'), False)
abaa.tag_subject_of(('*', 'seda_transfer_request_reply_identifier', '*'), False)
abaa.tag_object_of(('*', 'seda_transfer_request_reply_identifier', '*'), False)
abaa.tag_object_of(('*', 'seda_archival_agency', '*'), False)
abaa.tag_subject_of(('*', 'seda_archival_agency', '*'), False)
abaa.tag_object_of(('*', 'seda_transferring_agency', '*'), False)
abaa.tag_subject_of(('*', 'seda_transferring_agency', '*'), False)
abaa.tag_subject_of(('*', 'seda_message_digest_algorithm_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_message_digest_algorithm_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_message_digest_algorithm_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_message_digest_algorithm_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_mime_type_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_mime_type_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_mime_type_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_mime_type_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_encoding_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_encoding_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_encoding_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_encoding_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_file_format_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_file_format_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_file_format_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_file_format_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_compression_algorithm_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_compression_algorithm_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_compression_algorithm_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_compression_algorithm_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_data_object_version_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_version_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_version_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_data_object_version_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_storage_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_storage_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_storage_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_storage_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_appraisal_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_appraisal_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_appraisal_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_appraisal_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_access_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_access_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_access_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_access_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_dissemination_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_dissemination_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_dissemination_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_dissemination_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_reuse_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_reuse_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_reuse_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_reuse_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_classification_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_classification_rule_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_classification_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_classification_rule_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_acquisition_information_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_acquisition_information_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_acquisition_information_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_acquisition_information_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_relationship_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_relationship_code_list_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_relationship_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_relationship_code_list_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_binary_data_object', '*'), False)
abaa.tag_object_of(('*', 'seda_binary_data_object', '*'), False)
abaa.tag_subject_of(('*', 'seda_physical_data_object', '*'), False)
abaa.tag_object_of(('*', 'seda_physical_data_object', '*'), False)
abaa.tag_subject_of(('*', 'seda_relationship', '*'), False)
abaa.tag_object_of(('*', 'seda_relationship', '*'), False)
abaa.tag_subject_of(('*', 'seda_data_object_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_version_from', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_version_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_data_object_version_to', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_binary_data_object_attachment', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_binary_data_object_attachment', '*'), False)
abaa.tag_subject_of(('*', 'seda_compressed', '*'), False)
abaa.tag_object_of(('*', 'seda_compressed', '*'), False)
abaa.tag_subject_of(('*', 'seda_archive_unit', '*'), False)
abaa.tag_object_of(('*', 'seda_archive_unit', '*'), False)
abaa.tag_subject_of(('*', 'seda_service_level', '*'), False)
abaa.tag_object_of(('*', 'seda_service_level', '*'), False)
abaa.tag_subject_of(('*', 'seda_acquisition_information_from', '*'), False)
abaa.tag_object_of(('*', 'seda_acquisition_information_from', '*'), False)
abaa.tag_object_of(('*', 'seda_acquisition_information_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_acquisition_information_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_legal_status_from', '*'), False)
abaa.tag_object_of(('*', 'seda_legal_status_from', '*'), False)
abaa.tag_object_of(('*', 'seda_legal_status_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_legal_status_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_originating_agency_identifier', '*'), False)
abaa.tag_object_of(('*', 'seda_originating_agency_identifier', '*'), False)
abaa.tag_subject_of(('*', 'seda_submission_agency_identifier', '*'), False)
abaa.tag_object_of(('*', 'seda_submission_agency_identifier', '*'), False)
abaa.tag_subject_of(('*', 'seda_storage_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_storage_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_appraisal_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_appraisal_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_access_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_access_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_dissemination_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_dissemination_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_reuse_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_reuse_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_classification_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_classification_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_need_authorization', '*'), False)
abaa.tag_object_of(('*', 'seda_need_authorization', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_archive_unit_archive_unit_ref_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_archive_unit_archive_unit_ref_id', '*'), False)
abaa.tag_object_of(('*', 'seda_type_relationship', '*'), False)
abaa.tag_subject_of(('*', 'seda_type_relationship', '*'), False)
abaa.tag_object_of(('*', 'seda_target', '*'), False)
abaa.tag_subject_of(('*', 'seda_target', '*'), False)
abaa.tag_subject_of(('*', 'seda_attachment', '*'), False)
abaa.tag_object_of(('*', 'seda_attachment', '*'), False)
abaa.tag_subject_of(('*', 'seda_uri', '*'), False)
abaa.tag_object_of(('*', 'seda_uri', '*'), False)
abaa.tag_object_of(('*', 'seda_algorithm', '*'), False)
abaa.tag_subject_of(('*', 'seda_algorithm', '*'), False)
abaa.tag_subject_of(('*', 'seda_format_litteral', '*'), False)
abaa.tag_object_of(('*', 'seda_format_litteral', '*'), False)
abaa.tag_subject_of(('*', 'seda_mime_type_from', '*'), False)
abaa.tag_object_of(('*', 'seda_mime_type_from', '*'), False)
abaa.tag_object_of(('*', 'seda_mime_type_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_mime_type_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_format_id_from', '*'), False)
abaa.tag_object_of(('*', 'seda_format_id_from', '*'), False)
abaa.tag_object_of(('*', 'seda_format_id_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_format_id_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_encoding_from', '*'), False)
abaa.tag_object_of(('*', 'seda_encoding_from', '*'), False)
abaa.tag_object_of(('*', 'seda_encoding_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_encoding_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_creating_application_name', '*'), False)
abaa.tag_object_of(('*', 'seda_creating_application_name', '*'), False)
abaa.tag_subject_of(('*', 'seda_creating_application_version', '*'), False)
abaa.tag_object_of(('*', 'seda_creating_application_version', '*'), False)
abaa.tag_subject_of(('*', 'seda_date_created_by_application', '*'), False)
abaa.tag_object_of(('*', 'seda_date_created_by_application', '*'), False)
abaa.tag_subject_of(('*', 'seda_creating_os', '*'), False)
abaa.tag_object_of(('*', 'seda_creating_os', '*'), False)
abaa.tag_subject_of(('*', 'seda_creating_os_version', '*'), False)
abaa.tag_object_of(('*', 'seda_creating_os_version', '*'), False)
abaa.tag_subject_of(('*', 'seda_last_modified', '*'), False)
abaa.tag_object_of(('*', 'seda_last_modified', '*'), False)
abaa.tag_subject_of(('*', 'seda_width', '*'), False)
abaa.tag_object_of(('*', 'seda_width', '*'), False)
abaa.tag_subject_of(('*', 'seda_height', '*'), False)
abaa.tag_object_of(('*', 'seda_height', '*'), False)
abaa.tag_subject_of(('*', 'seda_depth', '*'), False)
abaa.tag_object_of(('*', 'seda_depth', '*'), False)
abaa.tag_subject_of(('*', 'seda_shape', '*'), False)
abaa.tag_object_of(('*', 'seda_shape', '*'), False)
abaa.tag_subject_of(('*', 'seda_diameter', '*'), False)
abaa.tag_object_of(('*', 'seda_diameter', '*'), False)
abaa.tag_subject_of(('*', 'seda_length', '*'), False)
abaa.tag_object_of(('*', 'seda_length', '*'), False)
abaa.tag_subject_of(('*', 'seda_thickness', '*'), False)
abaa.tag_object_of(('*', 'seda_thickness', '*'), False)
abaa.tag_subject_of(('*', 'seda_weight', '*'), False)
abaa.tag_object_of(('*', 'seda_weight', '*'), False)
abaa.tag_subject_of(('*', 'seda_number_of_page', '*'), False)
abaa.tag_object_of(('*', 'seda_number_of_page', '*'), False)
abaa.tag_subject_of(('*', 'seda_archive_unit_ref_id_from', '*'), False)
abaa.tag_object_of(('*', 'seda_archive_unit_ref_id_from', '*'), False)
abaa.tag_object_of(('*', 'seda_archive_unit_ref_id_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_archive_unit_ref_id_to', '*'), False)
abaa.tag_object_of(('*', 'seda_seq_alt_archive_unit_archive_unit_ref_id_management', '*'), False)
abaa.tag_subject_of(('*', 'seda_seq_alt_archive_unit_archive_unit_ref_id_management', '*'), False)
abaa.tag_object_of(('*', 'seda_seq_storage_rule_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_seq_storage_rule_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_storage_rule_prevent_inheritance', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_storage_rule_prevent_inheritance', '*'), False)
abaa.tag_object_of(('*', 'seda_final_action', '*'), False)
abaa.tag_subject_of(('*', 'seda_final_action', '*'), False)
abaa.tag_object_of(('*', 'seda_seq_appraisal_rule_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_seq_appraisal_rule_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_appraisal_rule_prevent_inheritance', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_appraisal_rule_prevent_inheritance', '*'), False)
abaa.tag_object_of(('*', 'seda_seq_access_rule_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_seq_access_rule_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_access_rule_prevent_inheritance', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_access_rule_prevent_inheritance', '*'), False)
abaa.tag_object_of(('*', 'seda_seq_dissemination_rule_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_seq_dissemination_rule_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_dissemination_rule_prevent_inheritance', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_dissemination_rule_prevent_inheritance', '*'), False)
abaa.tag_object_of(('*', 'seda_seq_reuse_rule_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_seq_reuse_rule_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_reuse_rule_prevent_inheritance', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_reuse_rule_prevent_inheritance', '*'), False)
abaa.tag_object_of(('*', 'seda_seq_classification_rule_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_seq_classification_rule_rule', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_classification_rule_prevent_inheritance', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_classification_rule_prevent_inheritance', '*'), False)
abaa.tag_object_of(('*', 'seda_classification_level', '*'), False)
abaa.tag_subject_of(('*', 'seda_classification_level', '*'), False)
abaa.tag_subject_of(('*', 'seda_classification_reassessing_date', '*'), False)
abaa.tag_object_of(('*', 'seda_classification_reassessing_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_need_reassessing_authorization', '*'), False)
abaa.tag_object_of(('*', 'seda_need_reassessing_authorization', '*'), False)
abaa.tag_subject_of(('*', 'seda_data_object_reference', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_reference', '*'), False)
abaa.tag_object_of(('*', 'seda_unit', '*'), False)
abaa.tag_subject_of(('*', 'seda_unit', '*'), False)
abaa.tag_object_of(('*', 'seda_description_level', '*'), False)
abaa.tag_subject_of(('*', 'seda_description_level', '*'), False)
abaa.tag_subject_of(('*', 'seda_title', '*'), False)
abaa.tag_object_of(('*', 'seda_title', '*'), False)
abaa.tag_subject_of(('*', 'seda_file_plan_position', '*'), False)
abaa.tag_object_of(('*', 'seda_file_plan_position', '*'), False)
abaa.tag_subject_of(('*', 'seda_system_id', '*'), False)
abaa.tag_object_of(('*', 'seda_system_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_originating_system_id', '*'), False)
abaa.tag_object_of(('*', 'seda_originating_system_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_archival_agency_archive_unit_identifier', '*'), False)
abaa.tag_object_of(('*', 'seda_archival_agency_archive_unit_identifier', '*'), False)
abaa.tag_subject_of(('*', 'seda_originating_agency_archive_unit_identifier', '*'), False)
abaa.tag_object_of(('*', 'seda_originating_agency_archive_unit_identifier', '*'), False)
abaa.tag_subject_of(('*', 'seda_transferring_agency_archive_unit_identifier', '*'), False)
abaa.tag_object_of(('*', 'seda_transferring_agency_archive_unit_identifier', '*'), False)
abaa.tag_subject_of(('*', 'seda_description', '*'), False)
abaa.tag_object_of(('*', 'seda_description', '*'), False)
abaa.tag_subject_of(('*', 'seda_type_from', '*'), False)
abaa.tag_object_of(('*', 'seda_type_from', '*'), False)
abaa.tag_object_of(('*', 'seda_type_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_type_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_document_type', '*'), False)
abaa.tag_object_of(('*', 'seda_document_type', '*'), False)
abaa.tag_subject_of(('*', 'seda_language_from', '*'), False)
abaa.tag_object_of(('*', 'seda_language_from', '*'), False)
abaa.tag_object_of(('*', 'seda_language_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_language_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_description_language_from', '*'), False)
abaa.tag_object_of(('*', 'seda_description_language_from', '*'), False)
abaa.tag_object_of(('*', 'seda_description_language_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_description_language_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_status', '*'), False)
abaa.tag_object_of(('*', 'seda_status', '*'), False)
abaa.tag_subject_of(('*', 'seda_version', '*'), False)
abaa.tag_object_of(('*', 'seda_version', '*'), False)
abaa.tag_subject_of(('*', 'seda_tag', '*'), False)
abaa.tag_object_of(('*', 'seda_tag', '*'), False)
abaa.tag_subject_of(('*', 'seda_keyword', '*'), False)
abaa.tag_object_of(('*', 'seda_keyword', '*'), False)
abaa.tag_subject_of(('*', 'seda_originating_agency_from', '*'), False)
abaa.tag_object_of(('*', 'seda_originating_agency_from', '*'), False)
abaa.tag_object_of(('*', 'seda_originating_agency_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_originating_agency_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_submission_agency_from', '*'), False)
abaa.tag_object_of(('*', 'seda_submission_agency_from', '*'), False)
abaa.tag_object_of(('*', 'seda_submission_agency_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_submission_agency_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_authorized_agent_from', '*'), False)
abaa.tag_object_of(('*', 'seda_authorized_agent_from', '*'), False)
abaa.tag_object_of(('*', 'seda_authorized_agent_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_authorized_agent_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_writer_from', '*'), False)
abaa.tag_object_of(('*', 'seda_writer_from', '*'), False)
abaa.tag_object_of(('*', 'seda_writer_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_writer_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_addressee_from', '*'), False)
abaa.tag_object_of(('*', 'seda_addressee_from', '*'), False)
abaa.tag_object_of(('*', 'seda_addressee_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_addressee_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_recipient_from', '*'), False)
abaa.tag_object_of(('*', 'seda_recipient_from', '*'), False)
abaa.tag_object_of(('*', 'seda_recipient_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_recipient_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_source', '*'), False)
abaa.tag_object_of(('*', 'seda_source', '*'), False)
abaa.tag_subject_of(('*', 'seda_created_date', '*'), False)
abaa.tag_object_of(('*', 'seda_created_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_transacted_date', '*'), False)
abaa.tag_object_of(('*', 'seda_transacted_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_acquired_date', '*'), False)
abaa.tag_object_of(('*', 'seda_acquired_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_sent_date', '*'), False)
abaa.tag_object_of(('*', 'seda_sent_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_received_date', '*'), False)
abaa.tag_object_of(('*', 'seda_received_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_registered_date', '*'), False)
abaa.tag_object_of(('*', 'seda_registered_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_start_date', '*'), False)
abaa.tag_object_of(('*', 'seda_start_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_end_date', '*'), False)
abaa.tag_object_of(('*', 'seda_end_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_event', '*'), False)
abaa.tag_object_of(('*', 'seda_event', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_reference_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_data_object_reference_id', '*'), False)
abaa.tag_object_of(('*', 'seda_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_rule', '*'), False)
abaa.tag_subject_of(('*', 'seda_prevent_inheritance', '*'), False)
abaa.tag_object_of(('*', 'seda_prevent_inheritance', '*'), False)
abaa.tag_subject_of(('*', 'seda_ref_non_rule_id_from', '*'), False)
abaa.tag_object_of(('*', 'seda_ref_non_rule_id_from', '*'), False)
abaa.tag_object_of(('*', 'seda_ref_non_rule_id_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_ref_non_rule_id_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_custodial_history_item', '*'), False)
abaa.tag_object_of(('*', 'seda_custodial_history_item', '*'), False)
abaa.tag_subject_of(('*', 'seda_custodial_history_file', '*'), False)
abaa.tag_object_of(('*', 'seda_custodial_history_file', '*'), False)
abaa.tag_subject_of(('*', 'seda_keyword_reference_from', '*'), False)
abaa.tag_object_of(('*', 'seda_keyword_reference_from', '*'), False)
abaa.tag_object_of(('*', 'seda_keyword_reference_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_keyword_reference_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_keyword_type_from', '*'), False)
abaa.tag_object_of(('*', 'seda_keyword_type_from', '*'), False)
abaa.tag_object_of(('*', 'seda_keyword_type_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_keyword_type_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_spatial', '*'), False)
abaa.tag_object_of(('*', 'seda_spatial', '*'), False)
abaa.tag_subject_of(('*', 'seda_temporal', '*'), False)
abaa.tag_object_of(('*', 'seda_temporal', '*'), False)
abaa.tag_subject_of(('*', 'seda_juridictional', '*'), False)
abaa.tag_object_of(('*', 'seda_juridictional', '*'), False)
abaa.tag_subject_of(('*', 'seda_is_version_of', '*'), False)
abaa.tag_object_of(('*', 'seda_is_version_of', '*'), False)
abaa.tag_subject_of(('*', 'seda_replaces', '*'), False)
abaa.tag_object_of(('*', 'seda_replaces', '*'), False)
abaa.tag_subject_of(('*', 'seda_requires', '*'), False)
abaa.tag_object_of(('*', 'seda_requires', '*'), False)
abaa.tag_subject_of(('*', 'seda_is_part_of', '*'), False)
abaa.tag_object_of(('*', 'seda_is_part_of', '*'), False)
abaa.tag_subject_of(('*', 'seda_references', '*'), False)
abaa.tag_object_of(('*', 'seda_references', '*'), False)
abaa.tag_subject_of(('*', 'seda_event_identifier', '*'), False)
abaa.tag_object_of(('*', 'seda_event_identifier', '*'), False)
abaa.tag_subject_of(('*', 'seda_event_type_from', '*'), False)
abaa.tag_object_of(('*', 'seda_event_type_from', '*'), False)
abaa.tag_object_of(('*', 'seda_event_type_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_event_type_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_event_detail', '*'), False)
abaa.tag_object_of(('*', 'seda_event_detail', '*'), False)
abaa.tag_subject_of(('*', 'seda_gps_version_id', '*'), False)
abaa.tag_object_of(('*', 'seda_gps_version_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_gps_altitude', '*'), False)
abaa.tag_object_of(('*', 'seda_gps_altitude', '*'), False)
abaa.tag_subject_of(('*', 'seda_gps_altitude_ref', '*'), False)
abaa.tag_object_of(('*', 'seda_gps_altitude_ref', '*'), False)
abaa.tag_subject_of(('*', 'seda_gps_latitude', '*'), False)
abaa.tag_object_of(('*', 'seda_gps_latitude', '*'), False)
abaa.tag_subject_of(('*', 'seda_gps_latitude_ref', '*'), False)
abaa.tag_object_of(('*', 'seda_gps_latitude_ref', '*'), False)
abaa.tag_subject_of(('*', 'seda_gps_longitude', '*'), False)
abaa.tag_object_of(('*', 'seda_gps_longitude', '*'), False)
abaa.tag_subject_of(('*', 'seda_gps_longitude_ref', '*'), False)
abaa.tag_object_of(('*', 'seda_gps_longitude_ref', '*'), False)
abaa.tag_subject_of(('*', 'seda_gps_date_stamp', '*'), False)
abaa.tag_object_of(('*', 'seda_gps_date_stamp', '*'), False)
abaa.tag_subject_of(('*', 'seda_when', '*'), False)
abaa.tag_object_of(('*', 'seda_when', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_is_version_of_archive_unit_ref_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_is_version_of_archive_unit_ref_id', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_replaces_archive_unit_ref_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_replaces_archive_unit_ref_id', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_requires_archive_unit_ref_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_requires_archive_unit_ref_id', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_is_part_of_archive_unit_ref_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_is_part_of_archive_unit_ref_id', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_references_archive_unit_ref_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_references_archive_unit_ref_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_repository_archive_unit_pid', '*'), False)
abaa.tag_object_of(('*', 'seda_repository_archive_unit_pid', '*'), False)
abaa.tag_subject_of(('*', 'seda_repository_object_pid', '*'), False)
abaa.tag_object_of(('*', 'seda_repository_object_pid', '*'), False)


affk = uicfg.autoform_field_kwargs
affk.tag_subject_of(('*', 'comment', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'archival_agreement', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'seda_message_digest_algorithm_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_mime_type_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_encoding_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_file_format_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_compression_algorithm_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_data_object_version_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_storage_rule_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_appraisal_rule_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_access_rule_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_dissemination_rule_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_reuse_rule_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_classification_rule_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_acquisition_information_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'seda_relationship_code_list_version_to', '*'), {'label': 'value'})
affk.tag_subject_of(('*', 'filename', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'compressed', '*'), {'allow_none': True})
affk.tag_subject_of(('*', 'service_level', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'originating_agency_identifier', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'submission_agency_identifier', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'classification_owner', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'need_authorization', '*'), {'allow_none': True})
affk.tag_subject_of(('*', 'format_litteral', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'creating_application_name', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'creating_application_version', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'creating_os', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'creating_os_version', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'need_reassessing_authorization', '*'), {'allow_none': True})
affk.tag_subject_of(('*', 'title', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'file_plan_position', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'archival_agency_archive_unit_identifier', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'originating_agency_archive_unit_identifier', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'transferring_agency_archive_unit_identifier', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'description', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'document_type', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'status', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'version', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'tag', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'keyword_content', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'source', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'prevent_inheritance', '*'), {'allow_none': True})
affk.tag_subject_of(('*', 'custodial_history_item', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'spatial', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'temporal', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'juridictional', '*'), {'widget': fw.TextInput({'size': 80})})


afs = uicfg.autoform_section
afs.tag_subject_of(('*', 'seda_comment', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_comment', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_signature', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_signature', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_archival_agreement', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_archival_agreement', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_related_transfer_reference', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_related_transfer_reference', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_transfer_request_reply_identifier', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_transfer_request_reply_identifier', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_archival_agency', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_archival_agency', '*'), 'main', 'attributes')
afs.tag_object_of(('*', 'seda_transferring_agency', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_transferring_agency', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_message_digest_algorithm_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_message_digest_algorithm_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_message_digest_algorithm_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_message_digest_algorithm_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_mime_type_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_mime_type_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_mime_type_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_mime_type_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_encoding_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_encoding_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_encoding_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_encoding_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_file_format_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_file_format_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_file_format_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_file_format_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_compression_algorithm_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_compression_algorithm_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_compression_algorithm_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_compression_algorithm_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_data_object_version_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_data_object_version_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_data_object_version_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_data_object_version_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_storage_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_storage_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_storage_rule_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_storage_rule_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_appraisal_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_appraisal_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_appraisal_rule_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_appraisal_rule_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_access_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_access_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_access_rule_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_access_rule_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_dissemination_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_dissemination_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_dissemination_rule_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_dissemination_rule_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_reuse_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_reuse_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_reuse_rule_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_reuse_rule_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_classification_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_classification_rule_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_classification_rule_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_classification_rule_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_acquisition_information_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_acquisition_information_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_acquisition_information_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_acquisition_information_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_relationship_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_relationship_code_list_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_relationship_code_list_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_relationship_code_list_version_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_binary_data_object', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_binary_data_object', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_physical_data_object', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_physical_data_object', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_relationship', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_relationship', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_data_object_version_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_data_object_version_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_data_object_version_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_data_object_version_to', '*'), 'main', 'attributes')
afs.tag_object_of(('*', 'seda_alt_binary_data_object_attachment', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_binary_data_object_attachment', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_compressed', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_compressed', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_archive_unit', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_archive_unit', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_service_level', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_service_level', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_acquisition_information_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_acquisition_information_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_acquisition_information_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_acquisition_information_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_legal_status_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_legal_status_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_legal_status_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_legal_status_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_originating_agency_identifier', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_originating_agency_identifier', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_submission_agency_identifier', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_submission_agency_identifier', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_storage_rule', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_storage_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_appraisal_rule', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_appraisal_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_access_rule', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_access_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_dissemination_rule', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_dissemination_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_reuse_rule', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_reuse_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_classification_rule', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_classification_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_need_authorization', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_need_authorization', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_alt_archive_unit_archive_unit_ref_id', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_archive_unit_archive_unit_ref_id', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_type_relationship', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_type_relationship', '*'), 'main', 'attributes')
afs.tag_object_of(('*', 'seda_target', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_target', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_attachment', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_attachment', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_uri', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_uri', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_algorithm', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_algorithm', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_format_litteral', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_format_litteral', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_mime_type_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_mime_type_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_mime_type_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_mime_type_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_format_id_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_format_id_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_format_id_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_format_id_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_encoding_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_encoding_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_encoding_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_encoding_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_creating_application_name', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_creating_application_name', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_creating_application_version', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_creating_application_version', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_date_created_by_application', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_date_created_by_application', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_creating_os', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_creating_os', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_creating_os_version', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_creating_os_version', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_last_modified', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_last_modified', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_width', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_width', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_height', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_height', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_depth', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_depth', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_shape', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_shape', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_diameter', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_diameter', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_length', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_length', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_thickness', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_thickness', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_weight', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_weight', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_number_of_page', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_number_of_page', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_archive_unit_ref_id_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_archive_unit_ref_id_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_archive_unit_ref_id_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_archive_unit_ref_id_to', '*'), 'main', 'attributes')
afs.tag_object_of(('*', 'seda_seq_alt_archive_unit_archive_unit_ref_id_management', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_seq_alt_archive_unit_archive_unit_ref_id_management', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_seq_storage_rule_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_seq_storage_rule_rule', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_storage_rule_prevent_inheritance', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_storage_rule_prevent_inheritance', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_final_action', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_final_action', '*'), 'main', 'attributes')
afs.tag_object_of(('*', 'seda_seq_appraisal_rule_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_seq_appraisal_rule_rule', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_appraisal_rule_prevent_inheritance', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_appraisal_rule_prevent_inheritance', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_seq_access_rule_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_seq_access_rule_rule', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_access_rule_prevent_inheritance', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_access_rule_prevent_inheritance', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_seq_dissemination_rule_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_seq_dissemination_rule_rule', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_dissemination_rule_prevent_inheritance', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_dissemination_rule_prevent_inheritance', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_seq_reuse_rule_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_seq_reuse_rule_rule', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_reuse_rule_prevent_inheritance', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_reuse_rule_prevent_inheritance', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_seq_classification_rule_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_seq_classification_rule_rule', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_classification_rule_prevent_inheritance', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_classification_rule_prevent_inheritance', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_classification_level', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_classification_level', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_classification_reassessing_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_classification_reassessing_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_need_reassessing_authorization', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_need_reassessing_authorization', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_data_object_reference', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_data_object_reference', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_unit', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_unit', '*'), 'main', 'attributes')
afs.tag_object_of(('*', 'seda_description_level', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_description_level', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_title', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_title', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_file_plan_position', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_file_plan_position', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_system_id', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_system_id', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_originating_system_id', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_originating_system_id', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_archival_agency_archive_unit_identifier', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_archival_agency_archive_unit_identifier', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_originating_agency_archive_unit_identifier', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_originating_agency_archive_unit_identifier', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_transferring_agency_archive_unit_identifier', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_transferring_agency_archive_unit_identifier', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_description', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_description', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_type_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_type_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_type_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_type_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_document_type', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_document_type', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_language_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_language_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_language_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_language_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_description_language_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_description_language_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_description_language_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_description_language_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_status', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_status', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_version', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_version', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_tag', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_tag', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_keyword', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_keyword', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_originating_agency_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_originating_agency_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_originating_agency_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_originating_agency_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_submission_agency_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_submission_agency_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_submission_agency_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_submission_agency_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_authorized_agent_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_authorized_agent_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_authorized_agent_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_authorized_agent_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_writer_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_writer_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_writer_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_writer_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_addressee_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_addressee_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_addressee_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_addressee_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_recipient_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_recipient_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_recipient_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_recipient_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_source', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_source', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_created_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_created_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_transacted_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_transacted_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_acquired_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_acquired_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_sent_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_sent_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_received_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_received_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_registered_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_registered_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_start_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_start_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_end_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_end_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_event', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_event', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_data_object_reference_id', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_data_object_reference_id', '*'), 'main', 'attributes')
afs.tag_object_of(('*', 'seda_rule', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_rule', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_prevent_inheritance', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_prevent_inheritance', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_ref_non_rule_id_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_ref_non_rule_id_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_ref_non_rule_id_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_ref_non_rule_id_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_custodial_history_item', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_custodial_history_item', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_custodial_history_file', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_custodial_history_file', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_keyword_reference_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_keyword_reference_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_keyword_reference_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_keyword_reference_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_keyword_type_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_keyword_type_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_keyword_type_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_keyword_type_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_spatial', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_spatial', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_temporal', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_temporal', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_juridictional', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_juridictional', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_is_version_of', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_is_version_of', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_replaces', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_replaces', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_requires', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_requires', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_is_part_of', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_is_part_of', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_references', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_references', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_event_identifier', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_event_identifier', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_event_type_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_event_type_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_event_type_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_event_type_to', '*'), 'main', 'attributes')
afs.tag_subject_of(('*', 'seda_event_detail', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_event_detail', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_gps_version_id', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_gps_version_id', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_gps_altitude', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_gps_altitude', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_gps_altitude_ref', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_gps_altitude_ref', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_gps_latitude', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_gps_latitude', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_gps_latitude_ref', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_gps_latitude_ref', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_gps_longitude', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_gps_longitude', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_gps_longitude_ref', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_gps_longitude_ref', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_gps_date_stamp', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_gps_date_stamp', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_when', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_when', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_is_version_of_archive_unit_ref_id', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_is_version_of_archive_unit_ref_id', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_replaces_archive_unit_ref_id', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_replaces_archive_unit_ref_id', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_requires_archive_unit_ref_id', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_requires_archive_unit_ref_id', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_is_part_of_archive_unit_ref_id', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_is_part_of_archive_unit_ref_id', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_references_archive_unit_ref_id', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_references_archive_unit_ref_id', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_repository_archive_unit_pid', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_repository_archive_unit_pid', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_repository_object_pid', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_repository_object_pid', '*'), 'main', 'inlined')


pvs = uicfg.primaryview_section
pvs.tag_subject_of(('*', 'seda_related_transfer_reference', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_related_transfer_reference', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_archival_agency', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_transferring_agency', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_message_digest_algorithm_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_message_digest_algorithm_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_message_digest_algorithm_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_mime_type_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_mime_type_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_mime_type_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_encoding_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_encoding_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_encoding_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_file_format_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_file_format_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_file_format_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_compression_algorithm_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_compression_algorithm_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_compression_algorithm_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_data_object_version_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_data_object_version_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_data_object_version_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_storage_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_storage_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_storage_rule_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_appraisal_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_appraisal_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_appraisal_rule_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_access_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_access_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_access_rule_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_dissemination_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_dissemination_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_dissemination_rule_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_reuse_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_reuse_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_reuse_rule_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_classification_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_classification_rule_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_classification_rule_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_acquisition_information_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_acquisition_information_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_acquisition_information_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_relationship_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_relationship_code_list_version_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_relationship_code_list_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_binary_data_object', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_binary_data_object', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_physical_data_object', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_physical_data_object', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_relationship', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_relationship', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_data_object_version_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_archive_unit', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_archive_unit', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_acquisition_information_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_legal_status_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_storage_rule', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_storage_rule', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_appraisal_rule', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_appraisal_rule', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_access_rule', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_access_rule', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_dissemination_rule', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_dissemination_rule', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_reuse_rule', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_reuse_rule', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_classification_rule', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_classification_rule', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_need_authorization', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_need_authorization', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_type_relationship', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_algorithm', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_format_litteral', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_format_litteral', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_mime_type_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_mime_type_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_mime_type_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_format_id_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_format_id_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_format_id_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_encoding_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_encoding_from', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_encoding_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_creating_application_name', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_creating_application_name', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_creating_application_version', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_creating_application_version', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_date_created_by_application', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_date_created_by_application', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_creating_os', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_creating_os', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_creating_os_version', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_creating_os_version', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_last_modified', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_last_modified', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_width', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_width', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_height', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_height', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_depth', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_depth', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_shape', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_shape', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_diameter', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_diameter', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_length', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_length', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_thickness', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_thickness', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_weight', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_weight', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_number_of_page', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_number_of_page', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_final_action', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_classification_level', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_unit', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_description_level', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_type_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_language_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_description_language_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_originating_agency_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_submission_agency_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_authorized_agent_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_writer_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_addressee_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_recipient_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_rule', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_ref_non_rule_id_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_custodial_history_item', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_custodial_history_item', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_custodial_history_file', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_custodial_history_file', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_keyword_reference_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_keyword_type_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_spatial', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_spatial', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_temporal', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_temporal', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_juridictional', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_juridictional', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_is_version_of', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_is_version_of', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_replaces', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_replaces', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_requires', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_requires', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_is_part_of', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_is_part_of', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_references', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_references', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_event_type_to', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_gps_version_id', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_gps_version_id', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_gps_altitude', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_gps_altitude', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_gps_altitude_ref', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_gps_altitude_ref', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_gps_latitude', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_gps_latitude', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_gps_latitude_ref', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_gps_latitude_ref', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_gps_longitude', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_gps_longitude', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_gps_longitude_ref', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_gps_longitude_ref', '*'), 'hidden')
pvs.tag_subject_of(('*', 'seda_gps_date_stamp', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_gps_date_stamp', '*'), 'hidden')


rec = uicfg.reledit_ctrl
rec.tag_subject_of(('*', 'comment', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_comment', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_signature', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'archival_agreement', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_archival_agreement', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_transfer_request_reply_identifier', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_archival_agency', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_transferring_agency', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_message_digest_algorithm_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_message_digest_algorithm_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_mime_type_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_mime_type_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_encoding_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_encoding_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_file_format_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_file_format_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_compression_algorithm_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_compression_algorithm_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_data_object_version_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_data_object_version_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_storage_rule_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_storage_rule_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_appraisal_rule_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_appraisal_rule_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_access_rule_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_access_rule_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_dissemination_rule_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_dissemination_rule_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_reuse_rule_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_reuse_rule_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_classification_rule_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_classification_rule_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_acquisition_information_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_acquisition_information_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_relationship_code_list_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_relationship_code_list_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'filename', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_data_object_version_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_data_object_version_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_alt_binary_data_object_attachment', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'compressed', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_compressed', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'service_level', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_service_level', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_acquisition_information_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_acquisition_information_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_legal_status_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_legal_status_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'originating_agency_identifier', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_originating_agency_identifier', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'submission_agency_identifier', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_submission_agency_identifier', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_storage_rule', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_appraisal_rule', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_access_rule', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_dissemination_rule', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_reuse_rule', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'classification_owner', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_classification_rule', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'need_authorization', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_need_authorization', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_alt_archive_unit_archive_unit_ref_id', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_type_relationship', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_target', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_attachment', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_uri', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_algorithm', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'format_litteral', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_format_litteral', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_mime_type_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_mime_type_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_format_id_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_format_id_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_encoding_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_encoding_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'creating_application_name', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_creating_application_name', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'creating_application_version', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_creating_application_version', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_date_created_by_application', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'creating_os', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_creating_os', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'creating_os_version', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_creating_os_version', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_last_modified', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_width', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_height', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_depth', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_shape', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_diameter', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_length', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_thickness', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_weight', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_number_of_page', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_archive_unit_ref_id_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_archive_unit_ref_id_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_seq_alt_archive_unit_archive_unit_ref_id_management', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_alt_storage_rule_prevent_inheritance', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_final_action', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_alt_appraisal_rule_prevent_inheritance', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_alt_access_rule_prevent_inheritance', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_alt_dissemination_rule_prevent_inheritance', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_alt_reuse_rule_prevent_inheritance', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_alt_classification_rule_prevent_inheritance', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_classification_level', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_classification_reassessing_date', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'need_reassessing_authorization', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_need_reassessing_authorization', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_unit', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_description_level', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'title', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_title', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'file_plan_position', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_file_plan_position', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_system_id', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_originating_system_id', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'archival_agency_archive_unit_identifier', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_archival_agency_archive_unit_identifier', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'originating_agency_archive_unit_identifier', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_originating_agency_archive_unit_identifier', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'transferring_agency_archive_unit_identifier', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_transferring_agency_archive_unit_identifier', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'description', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_description', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_type_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_type_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'document_type', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_document_type', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_language_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_language_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_description_language_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_description_language_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'status', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_status', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'version', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_version', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'tag', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'keyword_content', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_originating_agency_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_originating_agency_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_submission_agency_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_submission_agency_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_authorized_agent_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_authorized_agent_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_writer_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_addressee_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_recipient_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'source', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_source', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_created_date', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_transacted_date', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_acquired_date', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_sent_date', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_received_date', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_registered_date', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_start_date', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_end_date', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_data_object_reference_id', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_rule', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'prevent_inheritance', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_prevent_inheritance', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_ref_non_rule_id_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'custodial_history_item', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_custodial_history_file', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_keyword_reference_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_keyword_reference_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_keyword_type_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_keyword_type_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'spatial', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'temporal', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'juridictional', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_event_identifier', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_event_type_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_event_type_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_event_detail', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_gps_version_id', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_gps_altitude', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_gps_altitude_ref', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_gps_latitude', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_gps_latitude_ref', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_gps_longitude', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_gps_longitude_ref', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_gps_date_stamp', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_when', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_alt_is_version_of_archive_unit_ref_id', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_alt_replaces_archive_unit_ref_id', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_alt_requires_archive_unit_ref_id', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_alt_is_part_of_archive_unit_ref_id', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_alt_references_archive_unit_ref_id', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_repository_archive_unit_pid', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_repository_object_pid', '*'), {'novalue_label': ' '})
pvds = uicfg.primaryview_display_ctrl
affk.set_fields_order('SEDAArchiveTransfer', ['title', 'user_annotation'])
pvds.set_fields_order('SEDAArchiveTransfer', ['title', 'user_annotation'])
affk.set_fields_order('SEDAComment', ['user_cardinality', 'comment', 'user_annotation'])
pvds.set_fields_order('SEDAComment', ['user_cardinality', 'comment', 'user_annotation'])
affk.set_fields_order('SEDAArchivalAgreement', ['user_cardinality', 'archival_agreement', 'user_annotation'])
pvds.set_fields_order('SEDAArchivalAgreement', ['user_cardinality', 'archival_agreement', 'user_annotation'])
affk.set_fields_order('SEDABinaryDataObject', ['filename', 'user_cardinality', 'user_annotation'])
pvds.set_fields_order('SEDABinaryDataObject', ['filename', 'user_cardinality', 'user_annotation'])
affk.set_fields_order('SEDAPhysicalDataObject', ['user_cardinality', 'user_annotation'])
pvds.set_fields_order('SEDAPhysicalDataObject', ['user_cardinality', 'user_annotation'])
affk.set_fields_order('SEDACompressed', ['user_cardinality', 'compressed', 'user_annotation'])
pvds.set_fields_order('SEDACompressed', ['user_cardinality', 'compressed', 'user_annotation'])
affk.set_fields_order('SEDAArchiveUnit', ['user_cardinality', 'user_annotation'])
pvds.set_fields_order('SEDAArchiveUnit', ['user_cardinality', 'user_annotation'])
affk.set_fields_order('SEDAServiceLevel', ['user_cardinality', 'service_level', 'user_annotation'])
pvds.set_fields_order('SEDAServiceLevel', ['user_cardinality', 'service_level', 'user_annotation'])
affk.set_fields_order('SEDAOriginatingAgencyIdentifier', ['user_cardinality', 'originating_agency_identifier', 'user_annotation'])
pvds.set_fields_order('SEDAOriginatingAgencyIdentifier', ['user_cardinality', 'originating_agency_identifier', 'user_annotation'])
affk.set_fields_order('SEDASubmissionAgencyIdentifier', ['user_cardinality', 'submission_agency_identifier', 'user_annotation'])
pvds.set_fields_order('SEDASubmissionAgencyIdentifier', ['user_cardinality', 'submission_agency_identifier', 'user_annotation'])
affk.set_fields_order('SEDAClassificationRule', ['user_cardinality', 'classification_owner', 'user_annotation'])
pvds.set_fields_order('SEDAClassificationRule', ['user_cardinality', 'classification_owner', 'user_annotation'])
affk.set_fields_order('SEDANeedAuthorization', ['user_cardinality', 'need_authorization', 'user_annotation'])
pvds.set_fields_order('SEDANeedAuthorization', ['user_cardinality', 'need_authorization', 'user_annotation'])
affk.set_fields_order('SEDAFormatLitteral', ['user_cardinality', 'format_litteral', 'user_annotation'])
pvds.set_fields_order('SEDAFormatLitteral', ['user_cardinality', 'format_litteral', 'user_annotation'])
affk.set_fields_order('SEDACreatingApplicationName', ['user_cardinality', 'creating_application_name', 'user_annotation'])
pvds.set_fields_order('SEDACreatingApplicationName', ['user_cardinality', 'creating_application_name', 'user_annotation'])
affk.set_fields_order('SEDACreatingApplicationVersion', ['user_cardinality', 'creating_application_version', 'user_annotation'])
pvds.set_fields_order('SEDACreatingApplicationVersion', ['user_cardinality', 'creating_application_version', 'user_annotation'])
affk.set_fields_order('SEDACreatingOs', ['user_cardinality', 'creating_os', 'user_annotation'])
pvds.set_fields_order('SEDACreatingOs', ['user_cardinality', 'creating_os', 'user_annotation'])
affk.set_fields_order('SEDACreatingOsVersion', ['user_cardinality', 'creating_os_version', 'user_annotation'])
pvds.set_fields_order('SEDACreatingOsVersion', ['user_cardinality', 'creating_os_version', 'user_annotation'])
affk.set_fields_order('SEDANeedReassessingAuthorization', ['user_cardinality', 'need_reassessing_authorization', 'user_annotation'])
pvds.set_fields_order('SEDANeedReassessingAuthorization', ['user_cardinality', 'need_reassessing_authorization', 'user_annotation'])
affk.set_fields_order('SEDATitle', ['user_cardinality', 'title', 'user_annotation'])
pvds.set_fields_order('SEDATitle', ['user_cardinality', 'title', 'user_annotation'])
affk.set_fields_order('SEDAFilePlanPosition', ['user_cardinality', 'file_plan_position', 'user_annotation'])
pvds.set_fields_order('SEDAFilePlanPosition', ['user_cardinality', 'file_plan_position', 'user_annotation'])
affk.set_fields_order('SEDAArchivalAgencyArchiveUnitIdentifier', ['user_cardinality', 'archival_agency_archive_unit_identifier', 'user_annotation'])
pvds.set_fields_order('SEDAArchivalAgencyArchiveUnitIdentifier', ['user_cardinality', 'archival_agency_archive_unit_identifier', 'user_annotation'])
affk.set_fields_order('SEDAOriginatingAgencyArchiveUnitIdentifier', ['user_cardinality', 'originating_agency_archive_unit_identifier', 'user_annotation'])
pvds.set_fields_order('SEDAOriginatingAgencyArchiveUnitIdentifier', ['user_cardinality', 'originating_agency_archive_unit_identifier', 'user_annotation'])
affk.set_fields_order('SEDATransferringAgencyArchiveUnitIdentifier', ['user_cardinality', 'transferring_agency_archive_unit_identifier', 'user_annotation'])
pvds.set_fields_order('SEDATransferringAgencyArchiveUnitIdentifier', ['user_cardinality', 'transferring_agency_archive_unit_identifier', 'user_annotation'])
affk.set_fields_order('SEDADescription', ['user_cardinality', 'description', 'user_annotation'])
pvds.set_fields_order('SEDADescription', ['user_cardinality', 'description', 'user_annotation'])
affk.set_fields_order('SEDADocumentType', ['user_cardinality', 'document_type', 'user_annotation'])
pvds.set_fields_order('SEDADocumentType', ['user_cardinality', 'document_type', 'user_annotation'])
affk.set_fields_order('SEDAStatus', ['user_cardinality', 'status', 'user_annotation'])
pvds.set_fields_order('SEDAStatus', ['user_cardinality', 'status', 'user_annotation'])
affk.set_fields_order('SEDAVersion', ['user_cardinality', 'version', 'user_annotation'])
pvds.set_fields_order('SEDAVersion', ['user_cardinality', 'version', 'user_annotation'])
affk.set_fields_order('SEDATag', ['user_cardinality', 'tag', 'user_annotation'])
pvds.set_fields_order('SEDATag', ['user_cardinality', 'tag', 'user_annotation'])
affk.set_fields_order('SEDAKeyword', ['user_cardinality', 'keyword_content', 'user_annotation'])
pvds.set_fields_order('SEDAKeyword', ['user_cardinality', 'keyword_content', 'user_annotation'])
affk.set_fields_order('SEDASource', ['user_cardinality', 'source', 'user_annotation'])
pvds.set_fields_order('SEDASource', ['user_cardinality', 'source', 'user_annotation'])
affk.set_fields_order('SEDACustodialHistoryItem', ['user_cardinality', 'custodial_history_item', 'user_annotation'])
pvds.set_fields_order('SEDACustodialHistoryItem', ['user_cardinality', 'custodial_history_item', 'user_annotation'])
affk.set_fields_order('SEDASpatial', ['user_cardinality', 'spatial', 'user_annotation'])
pvds.set_fields_order('SEDASpatial', ['user_cardinality', 'spatial', 'user_annotation'])
affk.set_fields_order('SEDATemporal', ['user_cardinality', 'temporal', 'user_annotation'])
pvds.set_fields_order('SEDATemporal', ['user_cardinality', 'temporal', 'user_annotation'])
affk.set_fields_order('SEDAJuridictional', ['user_cardinality', 'juridictional', 'user_annotation'])
pvds.set_fields_order('SEDAJuridictional', ['user_cardinality', 'juridictional', 'user_annotation'])

ETYPE_ATTR_DOC = {}
ETYPE_ATTR_DOC[('SEDAComment', 'seda_comment', 'subject')] = ('Comment', [u'Commentaire sur le message.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_comment', 'object')] = ('Comment', [u'Commentaire sur le message.'])
ETYPE_ATTR_DOC[('SEDASignature', 'seda_signature', 'subject')] = ('Signature', [u'Signature du message.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_signature', 'object')] = ('Signature', [u'Signature du message.'])
ETYPE_ATTR_DOC[('SEDAArchivalAgreement', 'seda_archival_agreement', 'subject')] = ('ArchivalAgreement', [u'Accord de service.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_archival_agreement', 'object')] = ('ArchivalAgreement', [u'Accord de service.'])
ETYPE_ATTR_DOC[('SEDARelatedTransferReference', 'seda_related_transfer_reference', 'subject')] = ('RelatedTransferReference', [u'Identifiant d\u2019un transfert associ\xe9.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_related_transfer_reference', 'object')] = ('RelatedTransferReference', [u'Identifiant d\u2019un transfert associ\xe9.'])
ETYPE_ATTR_DOC[('SEDATransferRequestReplyIdentifier', 'seda_transfer_request_reply_identifier', 'subject')] = ('TransferRequestReplyIdentifier', [u'Identifiant de la r\xe9ponse \xe0 une demande de transfert.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_transfer_request_reply_identifier', 'object')] = ('TransferRequestReplyIdentifier', [u'Identifiant de la r\xe9ponse \xe0 une demande de transfert.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_archival_agency', 'subject')] = ('ArchivalAgency', [u"Service d'archives responsable de la r\xe9ponse \xe0 une demande de transfert."])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_archival_agency', 'object')] = ('ArchivalAgency', [u"Service d'archives responsable de la r\xe9ponse \xe0 une demande de transfert."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_transferring_agency', 'subject')] = ('TransferringAgency', [u'Service versant responsable de la r\xe9ponse \xe0 une demande de transfert.'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_transferring_agency', 'object')] = ('TransferringAgency', [u'Service versant responsable de la r\xe9ponse \xe0 une demande de transfert.'])
ETYPE_ATTR_DOC[('SEDAMessageDigestAlgorithmCodeListVersion', 'seda_message_digest_algorithm_code_list_version_from', 'subject')] = ('MessageDigestAlgorithmCodeListVersion', [u"Liste de l'algorithme de hachage utilis\xe9 dans le message."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_message_digest_algorithm_code_list_version_from', 'object')] = ('MessageDigestAlgorithmCodeListVersion', [u"Liste de l'algorithme de hachage utilis\xe9 dans le message."])
ETYPE_ATTR_DOC[('SEDAMessageDigestAlgorithmCodeListVersion', 'seda_message_digest_algorithm_code_list_version_to', 'subject')] = ('MessageDigestAlgorithmCodeListVersion', [u"Liste de l'algorithme de hachage utilis\xe9 dans le message."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_message_digest_algorithm_code_list_version_to', 'object')] = ('MessageDigestAlgorithmCodeListVersion', [u"Liste de l'algorithme de hachage utilis\xe9 dans le message."])
ETYPE_ATTR_DOC[('SEDAMimeTypeCodeListVersion', 'seda_mime_type_code_list_version_from', 'subject')] = ('MimeTypeCodeListVersion', [u'Version de la liste de code du type Mime.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_mime_type_code_list_version_from', 'object')] = ('MimeTypeCodeListVersion', [u'Version de la liste de code du type Mime.'])
ETYPE_ATTR_DOC[('SEDAMimeTypeCodeListVersion', 'seda_mime_type_code_list_version_to', 'subject')] = ('MimeTypeCodeListVersion', [u'Version de la liste de code du type Mime.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_mime_type_code_list_version_to', 'object')] = ('MimeTypeCodeListVersion', [u'Version de la liste de code du type Mime.'])
ETYPE_ATTR_DOC[('SEDAEncodingCodeListVersion', 'seda_encoding_code_list_version_from', 'subject')] = ('EncodingCodeListVersion', [u"Version de la liste de code d'encodage du fichier."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_encoding_code_list_version_from', 'object')] = ('EncodingCodeListVersion', [u"Version de la liste de code d'encodage du fichier."])
ETYPE_ATTR_DOC[('SEDAEncodingCodeListVersion', 'seda_encoding_code_list_version_to', 'subject')] = ('EncodingCodeListVersion', [u"Version de la liste de code d'encodage du fichier."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_encoding_code_list_version_to', 'object')] = ('EncodingCodeListVersion', [u"Version de la liste de code d'encodage du fichier."])
ETYPE_ATTR_DOC[('SEDAFileFormatCodeListVersion', 'seda_file_format_code_list_version_from', 'subject')] = ('FileFormatCodeListVersion', [u"Version de la liste de code d'identification du format."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_file_format_code_list_version_from', 'object')] = ('FileFormatCodeListVersion', [u"Version de la liste de code d'identification du format."])
ETYPE_ATTR_DOC[('SEDAFileFormatCodeListVersion', 'seda_file_format_code_list_version_to', 'subject')] = ('FileFormatCodeListVersion', [u"Version de la liste de code d'identification du format."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_file_format_code_list_version_to', 'object')] = ('FileFormatCodeListVersion', [u"Version de la liste de code d'identification du format."])
ETYPE_ATTR_DOC[('SEDACompressionAlgorithmCodeListVersion', 'seda_compression_algorithm_code_list_version_from', 'subject')] = ('CompressionAlgorithmCodeListVersion', [u"Version de la liste de code de l'algorithme de compression."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_compression_algorithm_code_list_version_from', 'object')] = ('CompressionAlgorithmCodeListVersion', [u"Version de la liste de code de l'algorithme de compression."])
ETYPE_ATTR_DOC[('SEDACompressionAlgorithmCodeListVersion', 'seda_compression_algorithm_code_list_version_to', 'subject')] = ('CompressionAlgorithmCodeListVersion', [u"Version de la liste de code de l'algorithme de compression."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_compression_algorithm_code_list_version_to', 'object')] = ('CompressionAlgorithmCodeListVersion', [u"Version de la liste de code de l'algorithme de compression."])
ETYPE_ATTR_DOC[('SEDADataObjectVersionCodeListVersion', 'seda_data_object_version_code_list_version_from', 'subject')] = ('DataObjectVersionCodeListVersion', [u"Liste de codes correspondant aux diverses versions d'un objet-donn\xe9es au sein d\u2019un groupe d'objets-donn\xe9es (ex. original papier, conservation, diffusion, vignette, txt)."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_data_object_version_code_list_version_from', 'object')] = ('DataObjectVersionCodeListVersion', [u"Liste de codes correspondant aux diverses versions d'un objet-donn\xe9es au sein d\u2019un groupe d'objets-donn\xe9es (ex. original papier, conservation, diffusion, vignette, txt)."])
ETYPE_ATTR_DOC[('SEDADataObjectVersionCodeListVersion', 'seda_data_object_version_code_list_version_to', 'subject')] = ('DataObjectVersionCodeListVersion', [u"Liste de codes correspondant aux diverses versions d'un objet-donn\xe9es au sein d\u2019un groupe d'objets-donn\xe9es (ex. original papier, conservation, diffusion, vignette, txt)."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_data_object_version_code_list_version_to', 'object')] = ('DataObjectVersionCodeListVersion', [u"Liste de codes correspondant aux diverses versions d'un objet-donn\xe9es au sein d\u2019un groupe d'objets-donn\xe9es (ex. original papier, conservation, diffusion, vignette, txt)."])
ETYPE_ATTR_DOC[('SEDAStorageRuleCodeListVersion', 'seda_storage_rule_code_list_version_from', 'subject')] = ('StorageRuleCodeListVersion', [u"Version des listes de codes pour les r\xe8gles de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_storage_rule_code_list_version_from', 'object')] = ('StorageRuleCodeListVersion', [u"Version des listes de codes pour les r\xe8gles de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDAStorageRuleCodeListVersion', 'seda_storage_rule_code_list_version_to', 'subject')] = ('StorageRuleCodeListVersion', [u"Version des listes de codes pour les r\xe8gles de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_storage_rule_code_list_version_to', 'object')] = ('StorageRuleCodeListVersion', [u"Version des listes de codes pour les r\xe8gles de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDAAppraisalRuleCodeListVersion', 'seda_appraisal_rule_code_list_version_from', 'subject')] = ('AppraisalRuleCodeListVersion', [u"Version des listes de codes pour les r\xe8gles de dur\xe9e d'utilit\xe9 administrative."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_appraisal_rule_code_list_version_from', 'object')] = ('AppraisalRuleCodeListVersion', [u"Version des listes de codes pour les r\xe8gles de dur\xe9e d'utilit\xe9 administrative."])
ETYPE_ATTR_DOC[('SEDAAppraisalRuleCodeListVersion', 'seda_appraisal_rule_code_list_version_to', 'subject')] = ('AppraisalRuleCodeListVersion', [u"Version des listes de codes pour les r\xe8gles de dur\xe9e d'utilit\xe9 administrative."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_appraisal_rule_code_list_version_to', 'object')] = ('AppraisalRuleCodeListVersion', [u"Version des listes de codes pour les r\xe8gles de dur\xe9e d'utilit\xe9 administrative."])
ETYPE_ATTR_DOC[('SEDAAccessRuleCodeListVersion', 'seda_access_rule_code_list_version_from', 'subject')] = ('AccessRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de communicabilit\xe9.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_access_rule_code_list_version_from', 'object')] = ('AccessRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de communicabilit\xe9.'])
ETYPE_ATTR_DOC[('SEDAAccessRuleCodeListVersion', 'seda_access_rule_code_list_version_to', 'subject')] = ('AccessRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de communicabilit\xe9.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_access_rule_code_list_version_to', 'object')] = ('AccessRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de communicabilit\xe9.'])
ETYPE_ATTR_DOC[('SEDADisseminationRuleCodeListVersion', 'seda_dissemination_rule_code_list_version_from', 'subject')] = ('DisseminationRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de diffusion.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_dissemination_rule_code_list_version_from', 'object')] = ('DisseminationRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de diffusion.'])
ETYPE_ATTR_DOC[('SEDADisseminationRuleCodeListVersion', 'seda_dissemination_rule_code_list_version_to', 'subject')] = ('DisseminationRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de diffusion.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_dissemination_rule_code_list_version_to', 'object')] = ('DisseminationRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de diffusion.'])
ETYPE_ATTR_DOC[('SEDAReuseRuleCodeListVersion', 'seda_reuse_rule_code_list_version_from', 'subject')] = ('ReuseRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de r\xe9utilisation.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_reuse_rule_code_list_version_from', 'object')] = ('ReuseRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de r\xe9utilisation.'])
ETYPE_ATTR_DOC[('SEDAReuseRuleCodeListVersion', 'seda_reuse_rule_code_list_version_to', 'subject')] = ('ReuseRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de r\xe9utilisation.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_reuse_rule_code_list_version_to', 'object')] = ('ReuseRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de r\xe9utilisation.'])
ETYPE_ATTR_DOC[('SEDAClassificationRuleCodeListVersion', 'seda_classification_rule_code_list_version_from', 'subject')] = ('ClassificationRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de classification.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_classification_rule_code_list_version_from', 'object')] = ('ClassificationRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de classification.'])
ETYPE_ATTR_DOC[('SEDAClassificationRuleCodeListVersion', 'seda_classification_rule_code_list_version_to', 'subject')] = ('ClassificationRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de classification.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_classification_rule_code_list_version_to', 'object')] = ('ClassificationRuleCodeListVersion', [u'Version des listes de codes pour les r\xe8gles de classification.'])
ETYPE_ATTR_DOC[('SEDAAcquisitionInformationCodeListVersion', 'seda_acquisition_information_code_list_version_from', 'subject')] = ('AcquisitionInformationCodeListVersion', [u"Version de la liste de codes des modalit\xe9s d'entr\xe9e."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_acquisition_information_code_list_version_from', 'object')] = ('AcquisitionInformationCodeListVersion', [u"Version de la liste de codes des modalit\xe9s d'entr\xe9e."])
ETYPE_ATTR_DOC[('SEDAAcquisitionInformationCodeListVersion', 'seda_acquisition_information_code_list_version_to', 'subject')] = ('AcquisitionInformationCodeListVersion', [u"Version de la liste de codes des modalit\xe9s d'entr\xe9e."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_acquisition_information_code_list_version_to', 'object')] = ('AcquisitionInformationCodeListVersion', [u"Version de la liste de codes des modalit\xe9s d'entr\xe9e."])
ETYPE_ATTR_DOC[('SEDARelationshipCodeListVersion', 'seda_relationship_code_list_version_from', 'subject')] = ('RelationshipCodeListVersion', [u'Version de la liste de codes des relations.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_relationship_code_list_version_from', 'object')] = ('RelationshipCodeListVersion', [u'Version de la liste de codes des relations.'])
ETYPE_ATTR_DOC[('SEDARelationshipCodeListVersion', 'seda_relationship_code_list_version_to', 'subject')] = ('RelationshipCodeListVersion', [u'Version de la liste de codes des relations.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_relationship_code_list_version_to', 'object')] = ('RelationshipCodeListVersion', [u'Version de la liste de codes des relations.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_binary_data_object', 'subject')] = ('BinaryDataObject', [u"Bloc de m\xe9tadonn\xe9es techniques des objets-donn\xe9es num\xe9riques. Le caract\xe8re facultatif est requis afin de permettre le transfert d'un plan de classement sans DataObject joint."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_binary_data_object', 'object')] = ('BinaryDataObject', [u"Bloc de m\xe9tadonn\xe9es techniques des objets-donn\xe9es num\xe9riques. Le caract\xe8re facultatif est requis afin de permettre le transfert d'un plan de classement sans DataObject joint."])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_physical_data_object', 'subject')] = ('PhysicalDataObject', [u'Bloc de m\xe9tadonn\xe9es techniques des objets-donn\xe9es physiques.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_physical_data_object', 'object')] = ('PhysicalDataObject', [u'Bloc de m\xe9tadonn\xe9es techniques des objets-donn\xe9es physiques.'])
ETYPE_ATTR_DOC[('SEDARelationship', 'seda_relationship', 'subject')] = ('Relationship', [u'Permet de sp\xe9cifier un lien technique entre un objet-donn\xe9es et une signature.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_relationship', 'object')] = ('Relationship', [u'Permet de sp\xe9cifier un lien technique entre un objet-donn\xe9es et une signature.'])
ETYPE_ATTR_DOC[('SEDADataObjectVersion', 'seda_data_object_version_from', 'subject')] = ('DataObjectVersion', [u'Version d\u2019un objet-donn\xe9es (par exemple : original papier, conservation, diffusion, vignette, txt, \u2026).'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_data_object_version_from', 'object')] = ('DataObjectVersion', [u'Version d\u2019un objet-donn\xe9es (par exemple : original papier, conservation, diffusion, vignette, txt, \u2026).'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_data_object_version_from', 'object')] = ('DataObjectVersion', [u'Version d\u2019un objet-donn\xe9es (par exemple : original papier, conservation, diffusion, vignette, txt, \u2026).'])
ETYPE_ATTR_DOC[('SEDADataObjectVersion', 'seda_data_object_version_to', 'subject')] = ('DataObjectVersion', [u'Version d\u2019un objet-donn\xe9es (par exemple : original papier, conservation, diffusion, vignette, txt, \u2026).'])
ETYPE_ATTR_DOC[('Concept', 'seda_data_object_version_to', 'object')] = ('DataObjectVersion', [u'Version d\u2019un objet-donn\xe9es (par exemple : original papier, conservation, diffusion, vignette, txt, \u2026).'])
ETYPE_ATTR_DOC[('SEDACompressed', 'seda_compressed', 'subject')] = ('Compressed', [u'Indique si l\u2019objet-donn\xe9es est compress\xe9 et doit \xeatre d\xe9compress\xe9.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_compressed', 'object')] = ('Compressed', [u'Indique si l\u2019objet-donn\xe9es est compress\xe9 et doit \xeatre d\xe9compress\xe9.'])
ETYPE_ATTR_DOC[('SEDARelationship', 'seda_relationship', 'subject')] = ('Relationship', [u'Permet de sp\xe9cifier un lien technique entre un objet-donn\xe9es et une signature.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_relationship', 'object')] = ('Relationship', [u'Permet de sp\xe9cifier un lien technique entre un objet-donn\xe9es et une signature.'])
ETYPE_ATTR_DOC[('SEDAArchiveUnit', 'seda_archive_unit', 'subject')] = ('ArchiveUnit', [u'Correspond \xe0 la notion de composant en ISAD(G). ArchiveUnit permet \xe0 la fois de g\xe9rer la hi\xe9rarchie intellectuelle, \n                        tout en contenant les m\xe9tadonn\xe9es de description et de gestion propres \xe0 chaque niveau de description archivistique.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_archive_unit', 'object')] = ('ArchiveUnit', [u'Correspond \xe0 la notion de composant en ISAD(G). ArchiveUnit permet \xe0 la fois de g\xe9rer la hi\xe9rarchie intellectuelle, \n                        tout en contenant les m\xe9tadonn\xe9es de description et de gestion propres \xe0 chaque niveau de description archivistique.'])
ETYPE_ATTR_DOC[('SEDAServiceLevel', 'seda_service_level', 'subject')] = ('ServiceLevel', [u'Niveau de service applicable aux unit\xe9s d\u2019archives.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_service_level', 'object')] = ('ServiceLevel', [u'Niveau de service applicable aux unit\xe9s d\u2019archives.'])
ETYPE_ATTR_DOC[('SEDAAcquisitionInformation', 'seda_acquisition_information_from', 'subject')] = ('AcquisitionInformation', [u"Modalit\xe9s d'entr\xe9e des archives."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_acquisition_information_from', 'object')] = ('AcquisitionInformation', [u"Modalit\xe9s d'entr\xe9e des archives."])
ETYPE_ATTR_DOC[('SEDAAcquisitionInformation', 'seda_acquisition_information_to', 'subject')] = ('AcquisitionInformation', [u"Modalit\xe9s d'entr\xe9e des archives."])
ETYPE_ATTR_DOC[('Concept', 'seda_acquisition_information_to', 'object')] = ('AcquisitionInformation', [u"Modalit\xe9s d'entr\xe9e des archives."])
ETYPE_ATTR_DOC[('SEDALegalStatus', 'seda_legal_status_from', 'subject')] = ('LegalStatus', [u'Statut des archives \xe9chang\xe9es.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_legal_status_from', 'object')] = ('LegalStatus', [u'Statut des archives \xe9chang\xe9es.'])
ETYPE_ATTR_DOC[('SEDALegalStatus', 'seda_legal_status_to', 'subject')] = ('LegalStatus', [u'Statut des archives \xe9chang\xe9es.'])
ETYPE_ATTR_DOC[('Concept', 'seda_legal_status_to', 'object')] = ('LegalStatus', [u'Statut des archives \xe9chang\xe9es.'])
ETYPE_ATTR_DOC[('SEDAOriginatingAgencyIdentifier', 'seda_originating_agency_identifier', 'subject')] = ('OriginatingAgencyIdentifier', [u'Identifiant du service producteur - information de gestion \xe0 ne pas confondre avec OriginatingAgency dans les m\xe9tadonn\xe9es de description.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_originating_agency_identifier', 'object')] = ('OriginatingAgencyIdentifier', [u'Identifiant du service producteur - information de gestion \xe0 ne pas confondre avec OriginatingAgency dans les m\xe9tadonn\xe9es de description.'])
ETYPE_ATTR_DOC[('SEDASubmissionAgencyIdentifier', 'seda_submission_agency_identifier', 'subject')] = ('SubmissionAgencyIdentifier', [u'Identifiant du service versant - information de gestion \xe0 ne pas confondre avec SubmissionAgency dans les m\xe9tadonn\xe9es de description.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_submission_agency_identifier', 'object')] = ('SubmissionAgencyIdentifier', [u'Identifiant du service versant - information de gestion \xe0 ne pas confondre avec SubmissionAgency dans les m\xe9tadonn\xe9es de description.'])
ETYPE_ATTR_DOC[('SEDAStorageRule', 'seda_storage_rule', 'subject')] = ('StorageRule', [u'Gestion de la dur\xe9e d\u2019utilit\xe9 courante.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_storage_rule', 'object')] = ('StorageRule', [u'Gestion de la dur\xe9e d\u2019utilit\xe9 courante.'])
ETYPE_ATTR_DOC[('SEDAAppraisalRule', 'seda_appraisal_rule', 'subject')] = ('AppraisalRule', [u'Gestion de la dur\xe9e d\u2019utilit\xe9 administrative.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_appraisal_rule', 'object')] = ('AppraisalRule', [u'Gestion de la dur\xe9e d\u2019utilit\xe9 administrative.'])
ETYPE_ATTR_DOC[('SEDAAccessRule', 'seda_access_rule', 'subject')] = ('AccessRule', [u'Gestion de la communicabilit\xe9.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_access_rule', 'object')] = ('AccessRule', [u'Gestion de la communicabilit\xe9.'])
ETYPE_ATTR_DOC[('SEDADisseminationRule', 'seda_dissemination_rule', 'subject')] = ('DisseminationRule', [u'Gestion de la diffusion.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_dissemination_rule', 'object')] = ('DisseminationRule', [u'Gestion de la diffusion.'])
ETYPE_ATTR_DOC[('SEDAReuseRule', 'seda_reuse_rule', 'subject')] = ('ReuseRule', [u'Gestion de la r\xe9utilisation.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_reuse_rule', 'object')] = ('ReuseRule', [u'Gestion de la r\xe9utilisation.'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_classification_rule', 'subject')] = ('ClassificationRule', [u'Gestion de la classification.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_classification_rule', 'object')] = ('ClassificationRule', [u'Gestion de la classification.'])
ETYPE_ATTR_DOC[('SEDANeedAuthorization', 'seda_need_authorization', 'subject')] = ('NeedAuthorization', [u'Indique si une autorisation humaine est n\xe9cessaire pour v\xe9rifier ou valider les op\xe9rations de gestion des ArchiveUnit.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_need_authorization', 'object')] = ('NeedAuthorization', [u'Indique si une autorisation humaine est n\xe9cessaire pour v\xe9rifier ou valider les op\xe9rations de gestion des ArchiveUnit.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_need_authorization', 'object')] = ('NeedAuthorization', [u'Indique si une autorisation humaine est n\xe9cessaire pour v\xe9rifier ou valider les op\xe9rations de gestion des ArchiveUnit.'])
ETYPE_ATTR_DOC[('SEDARelationship', 'seda_type_relationship', 'subject')] = ('type', ())
ETYPE_ATTR_DOC[('Concept', 'seda_type_relationship', 'object')] = ('type', ())
ETYPE_ATTR_DOC[('SEDARelationship', 'seda_target', 'subject')] = ('target', ())
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_target', 'object')] = ('target', ())
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_target', 'object')] = ('target', ())
ETYPE_ATTR_DOC[('SEDAAttachment', 'seda_attachment', 'subject')] = ('Attachment', [u'Objet-donn\xe9es (contenu binaire ou fichier joint).'])
ETYPE_ATTR_DOC[('SEDAAltBinaryDataObjectAttachment', 'seda_attachment', 'object')] = ('Attachment', [u'Objet-donn\xe9es (contenu binaire ou fichier joint).'])
ETYPE_ATTR_DOC[('SEDAUri', 'seda_uri', 'subject')] = ('Uri', [u"L'URI sp\xe9cifie o\xf9 se trouve l'objet-donn\xe9es num\xe9rique. Peut correspondre \xe0 un chemin relatif."])
ETYPE_ATTR_DOC[('SEDAAltBinaryDataObjectAttachment', 'seda_uri', 'object')] = ('Uri', [u"L'URI sp\xe9cifie o\xf9 se trouve l'objet-donn\xe9es num\xe9rique. Peut correspondre \xe0 un chemin relatif."])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_algorithm', 'subject')] = ('algorithm', ())
ETYPE_ATTR_DOC[('Concept', 'seda_algorithm', 'object')] = ('algorithm', ())
ETYPE_ATTR_DOC[('SEDACompressed', 'seda_algorithm', 'subject')] = ('algorithm', ())
ETYPE_ATTR_DOC[('Concept', 'seda_algorithm', 'object')] = ('algorithm', ())
ETYPE_ATTR_DOC[('SEDAFormatLitteral', 'seda_format_litteral', 'subject')] = ('FormatLitteral', [u'Forme litt\xe9rale du nom du format.', u'Exemple : Microsoft Word Document.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_format_litteral', 'object')] = ('FormatLitteral', [u'Forme litt\xe9rale du nom du format.', u'Exemple : Microsoft Word Document.'])
ETYPE_ATTR_DOC[('SEDAMimeType', 'seda_mime_type_from', 'subject')] = ('MimeType', [u'Type Mime associ\xe9, potentiellement stable mais pas assez pr\xe9cis.', u'Exemple : application/msword'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_mime_type_from', 'object')] = ('MimeType', [u'Type Mime associ\xe9, potentiellement stable mais pas assez pr\xe9cis.', u'Exemple : application/msword'])
ETYPE_ATTR_DOC[('SEDAMimeType', 'seda_mime_type_to', 'subject')] = ('MimeType', [u'Type Mime associ\xe9, potentiellement stable mais pas assez pr\xe9cis.', u'Exemple : application/msword'])
ETYPE_ATTR_DOC[('Concept', 'seda_mime_type_to', 'object')] = ('MimeType', [u'Type Mime associ\xe9, potentiellement stable mais pas assez pr\xe9cis.', u'Exemple : application/msword'])
ETYPE_ATTR_DOC[('SEDAFormatId', 'seda_format_id_from', 'subject')] = ('FormatId', [u'Type sp\xe9cifique du format tel que d\xe9fini dans FormatIdCodeList.', u'Exemple : (Pronom)fmt/40'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_format_id_from', 'object')] = ('FormatId', [u'Type sp\xe9cifique du format tel que d\xe9fini dans FormatIdCodeList.', u'Exemple : (Pronom)fmt/40'])
ETYPE_ATTR_DOC[('SEDAFormatId', 'seda_format_id_to', 'subject')] = ('FormatId', [u'Type sp\xe9cifique du format tel que d\xe9fini dans FormatIdCodeList.', u'Exemple : (Pronom)fmt/40'])
ETYPE_ATTR_DOC[('Concept', 'seda_format_id_to', 'object')] = ('FormatId', [u'Type sp\xe9cifique du format tel que d\xe9fini dans FormatIdCodeList.', u'Exemple : (Pronom)fmt/40'])
ETYPE_ATTR_DOC[('SEDAEncoding', 'seda_encoding_from', 'subject')] = ('Encoding', [u'Encodage du fichier tel que d\xe9fini dans EncodingIdCodeList.', u'Exemple : Utf-8'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_encoding_from', 'object')] = ('Encoding', [u'Encodage du fichier tel que d\xe9fini dans EncodingIdCodeList.', u'Exemple : Utf-8'])
ETYPE_ATTR_DOC[('SEDAEncoding', 'seda_encoding_to', 'subject')] = ('Encoding', [u'Encodage du fichier tel que d\xe9fini dans EncodingIdCodeList.', u'Exemple : Utf-8'])
ETYPE_ATTR_DOC[('Concept', 'seda_encoding_to', 'object')] = ('Encoding', [u'Encodage du fichier tel que d\xe9fini dans EncodingIdCodeList.', u'Exemple : Utf-8'])
ETYPE_ATTR_DOC[('SEDACreatingApplicationName', 'seda_creating_application_name', 'subject')] = ('CreatingApplicationName', [u"Nom de l'application utilis\xe9e pour cr\xe9er le fichier."])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_creating_application_name', 'object')] = ('CreatingApplicationName', [u"Nom de l'application utilis\xe9e pour cr\xe9er le fichier."])
ETYPE_ATTR_DOC[('SEDACreatingApplicationVersion', 'seda_creating_application_version', 'subject')] = ('CreatingApplicationVersion', [u"Version de l'application utilis\xe9e pour cr\xe9er le fichier."])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_creating_application_version', 'object')] = ('CreatingApplicationVersion', [u"Version de l'application utilis\xe9e pour cr\xe9er le fichier."])
ETYPE_ATTR_DOC[('SEDADateCreatedByApplication', 'seda_date_created_by_application', 'subject')] = ('DateCreatedByApplication', [u'Date de cr\xe9ation du fichier.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_date_created_by_application', 'object')] = ('DateCreatedByApplication', [u'Date de cr\xe9ation du fichier.'])
ETYPE_ATTR_DOC[('SEDACreatingOs', 'seda_creating_os', 'subject')] = ('CreatingOs', [u'Syst\xe8me d\u2019exploitation utilis\xe9 pour cr\xe9er le fichier.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_creating_os', 'object')] = ('CreatingOs', [u'Syst\xe8me d\u2019exploitation utilis\xe9 pour cr\xe9er le fichier.'])
ETYPE_ATTR_DOC[('SEDACreatingOsVersion', 'seda_creating_os_version', 'subject')] = ('CreatingOsVersion', [u"Version du syst\xe8me d'exploitation utilis\xe9 pour cr\xe9er le fichier."])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_creating_os_version', 'object')] = ('CreatingOsVersion', [u"Version du syst\xe8me d'exploitation utilis\xe9 pour cr\xe9er le fichier."])
ETYPE_ATTR_DOC[('SEDALastModified', 'seda_last_modified', 'subject')] = ('LastModified', [u'Date de la derni\xe8re modification du fichier.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_last_modified', 'object')] = ('LastModified', [u'Date de la derni\xe8re modification du fichier.'])
ETYPE_ATTR_DOC[('SEDAWidth', 'seda_width', 'subject')] = ('Width', [u'M\xe9tadonn\xe9e de dimension physique : largeur.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_width', 'object')] = ('Width', [u'M\xe9tadonn\xe9e de dimension physique : largeur.'])
ETYPE_ATTR_DOC[('SEDAHeight', 'seda_height', 'subject')] = ('Height', [u'M\xe9tadonn\xe9e de dimension physique : hauteur.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_height', 'object')] = ('Height', [u'M\xe9tadonn\xe9e de dimension physique : hauteur.'])
ETYPE_ATTR_DOC[('SEDADepth', 'seda_depth', 'subject')] = ('Depth', [u'M\xe9tadonn\xe9e de dimension physique : profondeur.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_depth', 'object')] = ('Depth', [u'M\xe9tadonn\xe9e de dimension physique : profondeur.'])
ETYPE_ATTR_DOC[('SEDAShape', 'seda_shape', 'subject')] = ('Shape', [u'M\xe9tadonn\xe9e de dimension physique : forme.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_shape', 'object')] = ('Shape', [u'M\xe9tadonn\xe9e de dimension physique : forme.'])
ETYPE_ATTR_DOC[('SEDADiameter', 'seda_diameter', 'subject')] = ('Diameter', [u'M\xe9tadonn\xe9e de dimension physique : diam\xe8tre.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_diameter', 'object')] = ('Diameter', [u'M\xe9tadonn\xe9e de dimension physique : diam\xe8tre.'])
ETYPE_ATTR_DOC[('SEDALength', 'seda_length', 'subject')] = ('Length', [u'M\xe9tadonn\xe9e de dimension physique : longueur.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_length', 'object')] = ('Length', [u'M\xe9tadonn\xe9e de dimension physique : longueur.'])
ETYPE_ATTR_DOC[('SEDAThickness', 'seda_thickness', 'subject')] = ('Thickness', [u'M\xe9tadonn\xe9e de dimension physique : \xe9paisseur.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_thickness', 'object')] = ('Thickness', [u'M\xe9tadonn\xe9e de dimension physique : \xe9paisseur.'])
ETYPE_ATTR_DOC[('SEDAWeight', 'seda_weight', 'subject')] = ('Weight', [u'M\xe9tadonn\xe9e de dimension physique : poids.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_weight', 'object')] = ('Weight', [u'M\xe9tadonn\xe9e de dimension physique : poids.'])
ETYPE_ATTR_DOC[('SEDANumberOfPage', 'seda_number_of_page', 'subject')] = ('NumberOfPage', [u'M\xe9tadonn\xe9e de dimension physique : nombre de pages.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_number_of_page', 'object')] = ('NumberOfPage', [u'M\xe9tadonn\xe9e de dimension physique : nombre de pages.'])
ETYPE_ATTR_DOC[('SEDAArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'subject')] = ('ArchiveUnitRefId', [u"Permet de faire une r\xe9f\xe9rence \xe0 d'autres ArchiveUnit dans la m\xeame transaction."])
ETYPE_ATTR_DOC[('SEDAAltIsPartOfArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', [u"Permet de faire une r\xe9f\xe9rence \xe0 d'autres ArchiveUnit dans la m\xeame transaction."])
ETYPE_ATTR_DOC[('SEDAAltReferencesArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', [u"Permet de faire une r\xe9f\xe9rence \xe0 d'autres ArchiveUnit dans la m\xeame transaction."])
ETYPE_ATTR_DOC[('SEDAAltArchiveUnitArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', [u"Permet de faire une r\xe9f\xe9rence \xe0 d'autres ArchiveUnit dans la m\xeame transaction."])
ETYPE_ATTR_DOC[('SEDAAltRequiresArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', [u"Permet de faire une r\xe9f\xe9rence \xe0 d'autres ArchiveUnit dans la m\xeame transaction."])
ETYPE_ATTR_DOC[('SEDAAltReplacesArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', [u"Permet de faire une r\xe9f\xe9rence \xe0 d'autres ArchiveUnit dans la m\xeame transaction."])
ETYPE_ATTR_DOC[('SEDAAltIsVersionOfArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', [u"Permet de faire une r\xe9f\xe9rence \xe0 d'autres ArchiveUnit dans la m\xeame transaction."])
ETYPE_ATTR_DOC[('SEDAArchiveUnitRefId', 'seda_archive_unit_ref_id_to', 'subject')] = ('ArchiveUnitRefId', [u"Permet de faire une r\xe9f\xe9rence \xe0 d'autres ArchiveUnit dans la m\xeame transaction."])
ETYPE_ATTR_DOC[('SEDAArchiveUnit', 'seda_archive_unit_ref_id_to', 'object')] = ('ArchiveUnitRefId', [u"Permet de faire une r\xe9f\xe9rence \xe0 d'autres ArchiveUnit dans la m\xeame transaction."])
ETYPE_ATTR_DOC[('SEDAStorageRule', 'seda_final_action', 'subject')] = ('FinalAction', [u'Action \xe0 mettre en \u0153uvre au terme de la dur\xe9e de gestion.'])
ETYPE_ATTR_DOC[('Concept', 'seda_final_action', 'object')] = ('FinalAction', [u'Action \xe0 mettre en \u0153uvre au terme de la dur\xe9e de gestion.'])
ETYPE_ATTR_DOC[('SEDAAppraisalRule', 'seda_final_action', 'subject')] = ('FinalAction', [u'Action \xe0 mettre en \u0153uvre au terme de la dur\xe9e de gestion.'])
ETYPE_ATTR_DOC[('Concept', 'seda_final_action', 'object')] = ('FinalAction', [u'Action \xe0 mettre en \u0153uvre au terme de la dur\xe9e de gestion.'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_classification_level', 'subject')] = ('ClassificationLevel', [u'R\xe9f\xe9rence au niveau de classification.'])
ETYPE_ATTR_DOC[('Concept', 'seda_classification_level', 'object')] = ('ClassificationLevel', [u'R\xe9f\xe9rence au niveau de classification.'])
ETYPE_ATTR_DOC[('SEDAClassificationReassessingDate', 'seda_classification_reassessing_date', 'subject')] = ('ClassificationReassessingDate', [u'Date de r\xe9\xe9valuation de la classification.'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_classification_reassessing_date', 'object')] = ('ClassificationReassessingDate', [u'Date de r\xe9\xe9valuation de la classification.'])
ETYPE_ATTR_DOC[('SEDANeedReassessingAuthorization', 'seda_need_reassessing_authorization', 'subject')] = ('NeedReassessingAuthorization', [u'Indique si une autorisation humaine est n\xe9cessaire pour r\xe9\xe9valuer la classification.'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_need_reassessing_authorization', 'object')] = ('NeedReassessingAuthorization', [u'Indique si une autorisation humaine est n\xe9cessaire pour r\xe9\xe9valuer la classification.'])
ETYPE_ATTR_DOC[('SEDAArchiveUnit', 'seda_archive_unit', 'subject')] = ('ArchiveUnit', [u'Correspond \xe0 la notion de composant en ISAD(G). ArchiveUnit permet \xe0 la fois de g\xe9rer la hi\xe9rarchie intellectuelle, \n                        tout en contenant les m\xe9tadonn\xe9es de description et de gestion propres \xe0 chaque niveau de description archivistique.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_archive_unit', 'object')] = ('ArchiveUnit', [u'Correspond \xe0 la notion de composant en ISAD(G). ArchiveUnit permet \xe0 la fois de g\xe9rer la hi\xe9rarchie intellectuelle, \n                        tout en contenant les m\xe9tadonn\xe9es de description et de gestion propres \xe0 chaque niveau de description archivistique.'])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_data_object_reference', 'object')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDAWidth', 'seda_unit', 'subject')] = ('unit', ())
ETYPE_ATTR_DOC[('Concept', 'seda_unit', 'object')] = ('unit', ())
ETYPE_ATTR_DOC[('SEDAHeight', 'seda_unit', 'subject')] = ('unit', ())
ETYPE_ATTR_DOC[('Concept', 'seda_unit', 'object')] = ('unit', ())
ETYPE_ATTR_DOC[('SEDADepth', 'seda_unit', 'subject')] = ('unit', ())
ETYPE_ATTR_DOC[('Concept', 'seda_unit', 'object')] = ('unit', ())
ETYPE_ATTR_DOC[('SEDADiameter', 'seda_unit', 'subject')] = ('unit', ())
ETYPE_ATTR_DOC[('Concept', 'seda_unit', 'object')] = ('unit', ())
ETYPE_ATTR_DOC[('SEDALength', 'seda_unit', 'subject')] = ('unit', ())
ETYPE_ATTR_DOC[('Concept', 'seda_unit', 'object')] = ('unit', ())
ETYPE_ATTR_DOC[('SEDAThickness', 'seda_unit', 'subject')] = ('unit', ())
ETYPE_ATTR_DOC[('Concept', 'seda_unit', 'object')] = ('unit', ())
ETYPE_ATTR_DOC[('SEDAWeight', 'seda_unit', 'subject')] = ('unit', ())
ETYPE_ATTR_DOC[('Concept', 'seda_unit', 'object')] = ('unit', ())
ETYPE_ATTR_DOC[('SEDAStorageRule', 'seda_storage_rule', 'subject')] = ('StorageRule', [u'Gestion de la dur\xe9e d\u2019utilit\xe9 courante.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_storage_rule', 'object')] = ('StorageRule', [u'Gestion de la dur\xe9e d\u2019utilit\xe9 courante.'])
ETYPE_ATTR_DOC[('SEDAAppraisalRule', 'seda_appraisal_rule', 'subject')] = ('AppraisalRule', [u'Gestion de la dur\xe9e d\u2019utilit\xe9 administrative.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_appraisal_rule', 'object')] = ('AppraisalRule', [u'Gestion de la dur\xe9e d\u2019utilit\xe9 administrative.'])
ETYPE_ATTR_DOC[('SEDAAccessRule', 'seda_access_rule', 'subject')] = ('AccessRule', [u'Gestion de la communicabilit\xe9.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_access_rule', 'object')] = ('AccessRule', [u'Gestion de la communicabilit\xe9.'])
ETYPE_ATTR_DOC[('SEDADisseminationRule', 'seda_dissemination_rule', 'subject')] = ('DisseminationRule', [u'Gestion de la diffusion.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_dissemination_rule', 'object')] = ('DisseminationRule', [u'Gestion de la diffusion.'])
ETYPE_ATTR_DOC[('SEDAReuseRule', 'seda_reuse_rule', 'subject')] = ('ReuseRule', [u'Gestion de la r\xe9utilisation.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_reuse_rule', 'object')] = ('ReuseRule', [u'Gestion de la r\xe9utilisation.'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_classification_rule', 'subject')] = ('ClassificationRule', [u'Gestion de la classification.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_classification_rule', 'object')] = ('ClassificationRule', [u'Gestion de la classification.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_description_level', 'subject')] = ('DescriptionLevel', [u'Niveau de description au sens de la norme ISAD (G). Indique si l\u2019ArchiveUnit correspond \xe0 un fonds, \n                        \xe0 un sous-fonds, \xe0 une classe, \xe0 une s\xe9rie organique, \xe0 une sous-s\xe9rie organique, \xe0 un dossier, \xe0 un sous-dossier ou \xe0 une pi\xe8ce.', u'R\xe9f\xe9rence : seda.DescriptionLevel'])
ETYPE_ATTR_DOC[('Concept', 'seda_description_level', 'object')] = ('DescriptionLevel', [u'Niveau de description au sens de la norme ISAD (G). Indique si l\u2019ArchiveUnit correspond \xe0 un fonds, \n                        \xe0 un sous-fonds, \xe0 une classe, \xe0 une s\xe9rie organique, \xe0 une sous-s\xe9rie organique, \xe0 un dossier, \xe0 un sous-dossier ou \xe0 une pi\xe8ce.', u'R\xe9f\xe9rence : seda.DescriptionLevel'])
ETYPE_ATTR_DOC[('SEDATitle', 'seda_title', 'subject')] = ('Title', [u"Intitul\xe9 de l'ArchiveUnit.", u'R\xe9f\xe9rences : DC.Title ead.unittitle'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_title', 'object')] = ('Title', [u"Intitul\xe9 de l'ArchiveUnit.", u'R\xe9f\xe9rences : DC.Title ead.unittitle'])
ETYPE_ATTR_DOC[('SEDAFilePlanPosition', 'seda_file_plan_position', 'subject')] = ('FilePlanPosition', [u'Position de l\u2019ArchiveUnit dans le plan de classement du service producteur.', u'R\xe9f\xe9rences : seda.FilePlanPosition'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_file_plan_position', 'object')] = ('FilePlanPosition', [u'Position de l\u2019ArchiveUnit dans le plan de classement du service producteur.', u'R\xe9f\xe9rences : seda.FilePlanPosition'])
ETYPE_ATTR_DOC[('SEDASystemId', 'seda_system_id', 'subject')] = ('SystemId', [u'Identifiant attribu\xe9 aux objets. Il est attribu\xe9 par le SAE et correspond \xe0 un identifiant interne.', u'R\xe9f\xe9rences : ARMS'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_system_id', 'object')] = ('SystemId', [u'Identifiant attribu\xe9 aux objets. Il est attribu\xe9 par le SAE et correspond \xe0 un identifiant interne.', u'R\xe9f\xe9rences : ARMS'])
ETYPE_ATTR_DOC[('SEDAOriginatingSystemId', 'seda_originating_system_id', 'subject')] = ('OriginatingSystemId', [u'Identifiant syst\xe8me attribu\xe9 \xe0 l\u2019ArchiveUnit par l\u2019application du service producteur.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_originating_system_id', 'object')] = ('OriginatingSystemId', [u'Identifiant syst\xe8me attribu\xe9 \xe0 l\u2019ArchiveUnit par l\u2019application du service producteur.'])
ETYPE_ATTR_DOC[('SEDAArchivalAgencyArchiveUnitIdentifier', 'seda_archival_agency_archive_unit_identifier', 'subject')] = ('ArchivalAgencyArchiveUnitIdentifier', [u"Identifiant m\xe9tier attribu\xe9 \xe0 l'ArchiveUnit par le service d'archives. Peut \xeatre compar\xe9 \xe0 une cote."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_archival_agency_archive_unit_identifier', 'object')] = ('ArchivalAgencyArchiveUnitIdentifier', [u"Identifiant m\xe9tier attribu\xe9 \xe0 l'ArchiveUnit par le service d'archives. Peut \xeatre compar\xe9 \xe0 une cote."])
ETYPE_ATTR_DOC[('SEDAOriginatingAgencyArchiveUnitIdentifier', 'seda_originating_agency_archive_unit_identifier', 'subject')] = ('OriginatingAgencyArchiveUnitIdentifier', [u'Identifiant m\xe9tier attribu\xe9 \xe0 l\u2019ArchiveUnit par le service producteur.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_originating_agency_archive_unit_identifier', 'object')] = ('OriginatingAgencyArchiveUnitIdentifier', [u'Identifiant m\xe9tier attribu\xe9 \xe0 l\u2019ArchiveUnit par le service producteur.'])
ETYPE_ATTR_DOC[('SEDATransferringAgencyArchiveUnitIdentifier', 'seda_transferring_agency_archive_unit_identifier', 'subject')] = ('TransferringAgencyArchiveUnitIdentifier', [u"Identifiant attribu\xe9 \xe0 l'ArchiveUnit par le service versant."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_transferring_agency_archive_unit_identifier', 'object')] = ('TransferringAgencyArchiveUnitIdentifier', [u"Identifiant attribu\xe9 \xe0 l'ArchiveUnit par le service versant."])
ETYPE_ATTR_DOC[('SEDADescription', 'seda_description', 'subject')] = ('Description', [u'Description d\xe9taill\xe9e de l\u2019ArchiveUnit. Correspond \xe0 la pr\xe9sentation du contenu au sens de la norme ISAD(G).', u'R\xe9f\xe9rences : DC:Documentation'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_description', 'object')] = ('Description', [u'Description d\xe9taill\xe9e de l\u2019ArchiveUnit. Correspond \xe0 la pr\xe9sentation du contenu au sens de la norme ISAD(G).', u'R\xe9f\xe9rences : DC:Documentation'])
ETYPE_ATTR_DOC[('SEDAType', 'seda_type_from', 'subject')] = ('Type', [u'Type d\u2019information au sens de l\u2019OAIS (information de repr\xe9sentation, information de p\xe9rennisation, etc.).', u'R\xe9f\xe9rences : seda.DocumentType'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_type_from', 'object')] = ('Type', [u'Type d\u2019information au sens de l\u2019OAIS (information de repr\xe9sentation, information de p\xe9rennisation, etc.).', u'R\xe9f\xe9rences : seda.DocumentType'])
ETYPE_ATTR_DOC[('SEDAType', 'seda_type_to', 'subject')] = ('Type', [u'Type d\u2019information au sens de l\u2019OAIS (information de repr\xe9sentation, information de p\xe9rennisation, etc.).', u'R\xe9f\xe9rences : seda.DocumentType'])
ETYPE_ATTR_DOC[('Concept', 'seda_type_to', 'object')] = ('Type', [u'Type d\u2019information au sens de l\u2019OAIS (information de repr\xe9sentation, information de p\xe9rennisation, etc.).', u'R\xe9f\xe9rences : seda.DocumentType'])
ETYPE_ATTR_DOC[('SEDADocumentType', 'seda_document_type', 'subject')] = ('DocumentType', [u'Type de document au sens diplomatique du terme (ex. compte-rendu de r\xe9union, note, correspondance, etc.). Ne pas confondre avec Type.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_document_type', 'object')] = ('DocumentType', [u'Type de document au sens diplomatique du terme (ex. compte-rendu de r\xe9union, note, correspondance, etc.). Ne pas confondre avec Type.'])
ETYPE_ATTR_DOC[('SEDALanguage', 'seda_language_from', 'subject')] = ('Language', [u'Langue du contenu des objets-donn\xe9es.', u'R\xe9f\xe9rences : seda.Language'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_language_from', 'object')] = ('Language', [u'Langue du contenu des objets-donn\xe9es.', u'R\xe9f\xe9rences : seda.Language'])
ETYPE_ATTR_DOC[('SEDALanguage', 'seda_language_to', 'subject')] = ('Language', [u'Langue du contenu des objets-donn\xe9es.', u'R\xe9f\xe9rences : seda.Language'])
ETYPE_ATTR_DOC[('Concept', 'seda_language_to', 'object')] = ('Language', [u'Langue du contenu des objets-donn\xe9es.', u'R\xe9f\xe9rences : seda.Language'])
ETYPE_ATTR_DOC[('SEDADescriptionLanguage', 'seda_description_language_from', 'subject')] = ('DescriptionLanguage', [u'Langue utilis\xe9e pour les informations de repr\xe9sentation et de p\xe9rennisation.', u'R\xe9f\xe9rences : seda.DescriptionLanguage'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_description_language_from', 'object')] = ('DescriptionLanguage', [u'Langue utilis\xe9e pour les informations de repr\xe9sentation et de p\xe9rennisation.', u'R\xe9f\xe9rences : seda.DescriptionLanguage'])
ETYPE_ATTR_DOC[('SEDADescriptionLanguage', 'seda_description_language_to', 'subject')] = ('DescriptionLanguage', [u'Langue utilis\xe9e pour les informations de repr\xe9sentation et de p\xe9rennisation.', u'R\xe9f\xe9rences : seda.DescriptionLanguage'])
ETYPE_ATTR_DOC[('Concept', 'seda_description_language_to', 'object')] = ('DescriptionLanguage', [u'Langue utilis\xe9e pour les informations de repr\xe9sentation et de p\xe9rennisation.', u'R\xe9f\xe9rences : seda.DescriptionLanguage'])
ETYPE_ATTR_DOC[('SEDAStatus', 'seda_status', 'subject')] = ('Status', [u"Etat de l'objet-donn\xe9es (par rapport avec son cycle de vie). Permet par exemple d'indiquer si la signature du fichier a \xe9t\xe9 v\xe9rifi\xe9e avant le transfert aux archives.", u'R\xe9f\xe9rences : seda.Status'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_status', 'object')] = ('Status', [u"Etat de l'objet-donn\xe9es (par rapport avec son cycle de vie). Permet par exemple d'indiquer si la signature du fichier a \xe9t\xe9 v\xe9rifi\xe9e avant le transfert aux archives.", u'R\xe9f\xe9rences : seda.Status'])
ETYPE_ATTR_DOC[('SEDAVersion', 'seda_version', 'subject')] = ('Version', [u"Permet d'indiquer quelle est la version du document."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_version', 'object')] = ('Version', [u"Permet d'indiquer quelle est la version du document."])
ETYPE_ATTR_DOC[('SEDATag', 'seda_tag', 'subject')] = ('Tag', [u"Mots-cl\xe9s ou liste de mots-cl\xe9s g\xe9n\xe9riques. En ce qui concerne l'indexation, on pourra utiliser Tag ou Keyword en fonction de ce que l'on souhaite d\xe9crire."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_tag', 'object')] = ('Tag', [u"Mots-cl\xe9s ou liste de mots-cl\xe9s g\xe9n\xe9riques. En ce qui concerne l'indexation, on pourra utiliser Tag ou Keyword en fonction de ce que l'on souhaite d\xe9crire."])
ETYPE_ATTR_DOC[('SEDAKeyword', 'seda_keyword', 'subject')] = ('Keyword', [u"Mots-clef avec contexte inspir\xe9 du SEDA 1.0. En ce qui concerne l'indexation, on pourra utiliser Tag ou Keyword en fonction de ce que l'on souhaite d\xe9crire.", u'R\xe9f\xe9rences : seda.Keyword'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_keyword', 'object')] = ('Keyword', [u"Mots-clef avec contexte inspir\xe9 du SEDA 1.0. En ce qui concerne l'indexation, on pourra utiliser Tag ou Keyword en fonction de ce que l'on souhaite d\xe9crire.", u'R\xe9f\xe9rences : seda.Keyword'])
ETYPE_ATTR_DOC[('SEDAOriginatingAgency', 'seda_originating_agency_from', 'subject')] = ('OriginatingAgency', [u'Service producteur. "Personne physique ou morale, publique ou priv\xe9e, qui a produit, re\xe7u et conserv\xe9 des archives  dans l\'exercice de son activit\xe9", Dictionnaire de terminologie archivistique, direction des archives de France, 2002.', u'R\xe9f\xe9rences : seda.OriginatingAgency'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_originating_agency_from', 'object')] = ('OriginatingAgency', [u'Service producteur. "Personne physique ou morale, publique ou priv\xe9e, qui a produit, re\xe7u et conserv\xe9 des archives  dans l\'exercice de son activit\xe9", Dictionnaire de terminologie archivistique, direction des archives de France, 2002.', u'R\xe9f\xe9rences : seda.OriginatingAgency'])
ETYPE_ATTR_DOC[('SEDAOriginatingAgency', 'seda_originating_agency_to', 'subject')] = ('OriginatingAgency', [u'Service producteur. "Personne physique ou morale, publique ou priv\xe9e, qui a produit, re\xe7u et conserv\xe9 des archives  dans l\'exercice de son activit\xe9", Dictionnaire de terminologie archivistique, direction des archives de France, 2002.', u'R\xe9f\xe9rences : seda.OriginatingAgency'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_originating_agency_to', 'object')] = ('OriginatingAgency', [u'Service producteur. "Personne physique ou morale, publique ou priv\xe9e, qui a produit, re\xe7u et conserv\xe9 des archives  dans l\'exercice de son activit\xe9", Dictionnaire de terminologie archivistique, direction des archives de France, 2002.', u'R\xe9f\xe9rences : seda.OriginatingAgency'])
ETYPE_ATTR_DOC[('SEDASubmissionAgency', 'seda_submission_agency_from', 'subject')] = ('SubmissionAgency', [u'Service versant responsable du transfert des donn\xe9es.', u'R\xe9f\xe9rences : seda.SubmissionAgency'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_submission_agency_from', 'object')] = ('SubmissionAgency', [u'Service versant responsable du transfert des donn\xe9es.', u'R\xe9f\xe9rences : seda.SubmissionAgency'])
ETYPE_ATTR_DOC[('SEDASubmissionAgency', 'seda_submission_agency_to', 'subject')] = ('SubmissionAgency', [u'Service versant responsable du transfert des donn\xe9es.', u'R\xe9f\xe9rences : seda.SubmissionAgency'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_submission_agency_to', 'object')] = ('SubmissionAgency', [u'Service versant responsable du transfert des donn\xe9es.', u'R\xe9f\xe9rences : seda.SubmissionAgency'])
ETYPE_ATTR_DOC[('SEDAAuthorizedAgent', 'seda_authorized_agent_from', 'subject')] = ('AuthorizedAgent', [u'Titulaire des droits de propri\xe9t\xe9 intellectuelle.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_authorized_agent_from', 'object')] = ('AuthorizedAgent', [u'Titulaire des droits de propri\xe9t\xe9 intellectuelle.'])
ETYPE_ATTR_DOC[('SEDAAuthorizedAgent', 'seda_authorized_agent_to', 'subject')] = ('AuthorizedAgent', [u'Titulaire des droits de propri\xe9t\xe9 intellectuelle.'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_authorized_agent_to', 'object')] = ('AuthorizedAgent', [u'Titulaire des droits de propri\xe9t\xe9 intellectuelle.'])
ETYPE_ATTR_DOC[('SEDAWriter', 'seda_writer_from', 'subject')] = ('Writer', [u'R\xe9dacteur R\xe9dacteur de l\u2019ArchiveUnit.', u'R\xe9f\xe9rences : interpares.Writer'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_writer_from', 'object')] = ('Writer', [u'R\xe9dacteur R\xe9dacteur de l\u2019ArchiveUnit.', u'R\xe9f\xe9rences : interpares.Writer'])
ETYPE_ATTR_DOC[('SEDAWriter', 'seda_writer_to', 'subject')] = ('Writer', [u'R\xe9dacteur R\xe9dacteur de l\u2019ArchiveUnit.', u'R\xe9f\xe9rences : interpares.Writer'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_writer_to', 'object')] = ('Writer', [u'R\xe9dacteur R\xe9dacteur de l\u2019ArchiveUnit.', u'R\xe9f\xe9rences : interpares.Writer'])
ETYPE_ATTR_DOC[('SEDAAddressee', 'seda_addressee_from', 'subject')] = ('Addressee', [u'Destinataire pour action. Utilis\xe9 pour indiquer le nom du destinatire par exemple dans un courrier \xe9lectronique.', u'R\xe9f\xe9rences : ARMS.Addressee, Interpares.Addressee'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_addressee_from', 'object')] = ('Addressee', [u'Destinataire pour action. Utilis\xe9 pour indiquer le nom du destinatire par exemple dans un courrier \xe9lectronique.', u'R\xe9f\xe9rences : ARMS.Addressee, Interpares.Addressee'])
ETYPE_ATTR_DOC[('SEDAAddressee', 'seda_addressee_to', 'subject')] = ('Addressee', [u'Destinataire pour action. Utilis\xe9 pour indiquer le nom du destinatire par exemple dans un courrier \xe9lectronique.', u'R\xe9f\xe9rences : ARMS.Addressee, Interpares.Addressee'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_addressee_to', 'object')] = ('Addressee', [u'Destinataire pour action. Utilis\xe9 pour indiquer le nom du destinatire par exemple dans un courrier \xe9lectronique.', u'R\xe9f\xe9rences : ARMS.Addressee, Interpares.Addressee'])
ETYPE_ATTR_DOC[('SEDARecipient', 'seda_recipient_from', 'subject')] = ('Recipient', [u'Destinataire pour information. Utilis\xe9 pour indiquer le nom du destinatire en copie, pour information, par exemple dans un courrier \xe9lectronique.', u'R\xe9f\xe9rences : Interpares.Recipient'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_recipient_from', 'object')] = ('Recipient', [u'Destinataire pour information. Utilis\xe9 pour indiquer le nom du destinatire en copie, pour information, par exemple dans un courrier \xe9lectronique.', u'R\xe9f\xe9rences : Interpares.Recipient'])
ETYPE_ATTR_DOC[('SEDARecipient', 'seda_recipient_to', 'subject')] = ('Recipient', [u'Destinataire pour information. Utilis\xe9 pour indiquer le nom du destinatire en copie, pour information, par exemple dans un courrier \xe9lectronique.', u'R\xe9f\xe9rences : Interpares.Recipient'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_recipient_to', 'object')] = ('Recipient', [u'Destinataire pour information. Utilis\xe9 pour indiquer le nom du destinatire en copie, pour information, par exemple dans un courrier \xe9lectronique.', u'R\xe9f\xe9rences : Interpares.Recipient'])
ETYPE_ATTR_DOC[('SEDASource', 'seda_source', 'subject')] = ('Source', [u'En cas de substitution num\xe9rique, permet de faire r\xe9f\xe9rence au papier.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_source', 'object')] = ('Source', [u'En cas de substitution num\xe9rique, permet de faire r\xe9f\xe9rence au papier.'])
ETYPE_ATTR_DOC[('SEDACreatedDate', 'seda_created_date', 'subject')] = ('CreatedDate', [u'Date de cr\xe9ation.', u'R\xe9f\xe9rences : ARKMS.DateCreated'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_created_date', 'object')] = ('CreatedDate', [u'Date de cr\xe9ation.', u'R\xe9f\xe9rences : ARKMS.DateCreated'])
ETYPE_ATTR_DOC[('SEDATransactedDate', 'seda_transacted_date', 'subject')] = ('TransactedDate', [u'Date de la transaction.', u'R\xe9f\xe9rences : ARKMS.DateTransacted'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_transacted_date', 'object')] = ('TransactedDate', [u'Date de la transaction.', u'R\xe9f\xe9rences : ARKMS.DateTransacted'])
ETYPE_ATTR_DOC[('SEDAAcquiredDate', 'seda_acquired_date', 'subject')] = ('AcquiredDate', [u'Date de num\xe9risation.', u'R\xe9f\xe9rences : ARKMS.DateAcquired'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_acquired_date', 'object')] = ('AcquiredDate', [u'Date de num\xe9risation.', u'R\xe9f\xe9rences : ARKMS.DateAcquired'])
ETYPE_ATTR_DOC[('SEDASentDate', 'seda_sent_date', 'subject')] = ('SentDate', [u"Date d'envoi."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_sent_date', 'object')] = ('SentDate', [u"Date d'envoi."])
ETYPE_ATTR_DOC[('SEDAReceivedDate', 'seda_received_date', 'subject')] = ('ReceivedDate', [u'Date de r\xe9ception.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_received_date', 'object')] = ('ReceivedDate', [u'Date de r\xe9ception.'])
ETYPE_ATTR_DOC[('SEDARegisteredDate', 'seda_registered_date', 'subject')] = ('RegisteredDate', [u"Date d'enregistrement.", u'R\xe9f\xe9rences : ARMS.DateDeclared'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_registered_date', 'object')] = ('RegisteredDate', [u"Date d'enregistrement.", u'R\xe9f\xe9rences : ARMS.DateDeclared'])
ETYPE_ATTR_DOC[('SEDAStartDate', 'seda_start_date', 'subject')] = ('StartDate', [u"Date d'ouverture / date de d\xe9but.", u'R\xe9f\xe9rences : AGKRMS.StartDate'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_start_date', 'object')] = ('StartDate', [u"Date d'ouverture / date de d\xe9but.", u'R\xe9f\xe9rences : AGKRMS.StartDate'])
ETYPE_ATTR_DOC[('SEDAEndDate', 'seda_end_date', 'subject')] = ('EndDate', [u'Date de fermeture / Date de fin.', u'R\xe9f\xe9rences : AGKRMS.EndDate'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_end_date', 'object')] = ('EndDate', [u'Date de fermeture / Date de fin.', u'R\xe9f\xe9rences : AGKRMS.EndDate'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event', 'subject')] = ('Event', [u'Informations d\xe9crivant un \xe9v\xe9nement survenu au cours d\u2019une proc\xe9dure (ex. publication d\u2019un march\xe9, notification d\u2019un march\xe9, recueil d\u2019un avis administratif, etc.).'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_event', 'object')] = ('Event', [u'Informations d\xe9crivant un \xe9v\xe9nement survenu au cours d\u2019une proc\xe9dure (ex. publication d\u2019un march\xe9, notification d\u2019un march\xe9, recueil d\u2019un avis administratif, etc.).'])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference_id', 'subject')] = ('DataObjectReferenceId', [u'R\xe9f\xe9rence \xe0 un objet-donn\xe9es list\xe9 dans les m\xe9tadonn\xe9es de transport.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_data_object_reference_id', 'object')] = ('DataObjectReferenceId', [u'R\xe9f\xe9rence \xe0 un objet-donn\xe9es list\xe9 dans les m\xe9tadonn\xe9es de transport.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_data_object_reference_id', 'object')] = ('DataObjectReferenceId', [u'R\xe9f\xe9rence \xe0 un objet-donn\xe9es list\xe9 dans les m\xe9tadonn\xe9es de transport.'])
ETYPE_ATTR_DOC[('SEDASeqStorageRuleRule', 'seda_rule', 'subject')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDAStartDate', 'seda_start_date', 'subject')] = ('StartDate', [u"Date de d\xe9part de calcul de la r\xe8gle d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDASeqDisseminationRuleRule', 'seda_start_date', 'object')] = ('StartDate', [u"Date de d\xe9part de calcul de la r\xe8gle d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDASeqReuseRuleRule', 'seda_start_date', 'object')] = ('StartDate', [u"Date de d\xe9part de calcul de la r\xe8gle d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDASeqAppraisalRuleRule', 'seda_start_date', 'object')] = ('StartDate', [u"Date de d\xe9part de calcul de la r\xe8gle d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDASeqAccessRuleRule', 'seda_start_date', 'object')] = ('StartDate', [u"Date de d\xe9part de calcul de la r\xe8gle d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDASeqStorageRuleRule', 'seda_start_date', 'object')] = ('StartDate', [u"Date de d\xe9part de calcul de la r\xe8gle d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDASeqClassificationRuleRule', 'seda_start_date', 'object')] = ('StartDate', [u"Date de d\xe9part de calcul de la r\xe8gle d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDAPreventInheritance', 'seda_prevent_inheritance', 'subject')] = ('PreventInheritance', [u'Indique si les r\xe8gles de gestion h\xe9rit\xe9es des ArchiveUnit parents doivent \xeatre ignor\xe9es pour l\u2019ArchiveUnit concern\xe9.'])
ETYPE_ATTR_DOC[('SEDAAltReuseRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', [u'Indique si les r\xe8gles de gestion h\xe9rit\xe9es des ArchiveUnit parents doivent \xeatre ignor\xe9es pour l\u2019ArchiveUnit concern\xe9.'])
ETYPE_ATTR_DOC[('SEDAAltAppraisalRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', [u'Indique si les r\xe8gles de gestion h\xe9rit\xe9es des ArchiveUnit parents doivent \xeatre ignor\xe9es pour l\u2019ArchiveUnit concern\xe9.'])
ETYPE_ATTR_DOC[('SEDAAltAccessRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', [u'Indique si les r\xe8gles de gestion h\xe9rit\xe9es des ArchiveUnit parents doivent \xeatre ignor\xe9es pour l\u2019ArchiveUnit concern\xe9.'])
ETYPE_ATTR_DOC[('SEDAAltClassificationRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', [u'Indique si les r\xe8gles de gestion h\xe9rit\xe9es des ArchiveUnit parents doivent \xeatre ignor\xe9es pour l\u2019ArchiveUnit concern\xe9.'])
ETYPE_ATTR_DOC[('SEDAAltStorageRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', [u'Indique si les r\xe8gles de gestion h\xe9rit\xe9es des ArchiveUnit parents doivent \xeatre ignor\xe9es pour l\u2019ArchiveUnit concern\xe9.'])
ETYPE_ATTR_DOC[('SEDAAltDisseminationRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', [u'Indique si les r\xe8gles de gestion h\xe9rit\xe9es des ArchiveUnit parents doivent \xeatre ignor\xe9es pour l\u2019ArchiveUnit concern\xe9.'])
ETYPE_ATTR_DOC[('SEDARefNonRuleId', 'seda_ref_non_rule_id_from', 'subject')] = ('RefNonRuleId', [u"L'identifiant de la r\xe8gle sp\xe9cifi\xe9e pourra \xeatre retir\xe9e de l'h\xe9ritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltReuseRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', [u"L'identifiant de la r\xe8gle sp\xe9cifi\xe9e pourra \xeatre retir\xe9e de l'h\xe9ritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltAppraisalRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', [u"L'identifiant de la r\xe8gle sp\xe9cifi\xe9e pourra \xeatre retir\xe9e de l'h\xe9ritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltAccessRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', [u"L'identifiant de la r\xe8gle sp\xe9cifi\xe9e pourra \xeatre retir\xe9e de l'h\xe9ritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltClassificationRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', [u"L'identifiant de la r\xe8gle sp\xe9cifi\xe9e pourra \xeatre retir\xe9e de l'h\xe9ritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltStorageRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', [u"L'identifiant de la r\xe8gle sp\xe9cifi\xe9e pourra \xeatre retir\xe9e de l'h\xe9ritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltDisseminationRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', [u"L'identifiant de la r\xe8gle sp\xe9cifi\xe9e pourra \xeatre retir\xe9e de l'h\xe9ritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDARefNonRuleId', 'seda_ref_non_rule_id_to', 'subject')] = ('RefNonRuleId', [u"L'identifiant de la r\xe8gle sp\xe9cifi\xe9e pourra \xeatre retir\xe9e de l'h\xe9ritage dans ce noeud."])
ETYPE_ATTR_DOC[('Concept', 'seda_ref_non_rule_id_to', 'object')] = ('RefNonRuleId', [u"L'identifiant de la r\xe8gle sp\xe9cifi\xe9e pourra \xeatre retir\xe9e de l'h\xe9ritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDASeqAppraisalRuleRule', 'seda_rule', 'subject')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDASeqAccessRuleRule', 'seda_rule', 'subject')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDASeqDisseminationRuleRule', 'seda_rule', 'subject')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDASeqReuseRuleRule', 'seda_rule', 'subject')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDASeqClassificationRuleRule', 'seda_rule', 'subject')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', [u"R\xe9f\xe9rence \xe0 la r\xe8gle de dur\xe9e d'utilit\xe9 courante."])
ETYPE_ATTR_DOC[('SEDACustodialHistoryItem', 'seda_custodial_history_item', 'subject')] = ('CustodialHistoryItem', [u"Description d'une p\xe9riode ou d'un \xe9v\xe9nement pr\xe9cis dans l'historique.", u'R\xe9f\xe9rences : seda.CustodialHistoryItem'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_custodial_history_item', 'object')] = ('CustodialHistoryItem', [u"Description d'une p\xe9riode ou d'un \xe9v\xe9nement pr\xe9cis dans l'historique.", u'R\xe9f\xe9rences : seda.CustodialHistoryItem'])
ETYPE_ATTR_DOC[('SEDACustodialHistoryFile', 'seda_custodial_history_file', 'subject')] = ('CustodialHistoryFile', [u'R\xe9f\xe9rence \xe0 un fichier de journalisation externe.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_custodial_history_file', 'object')] = ('CustodialHistoryFile', [u'R\xe9f\xe9rence \xe0 un fichier de journalisation externe.'])
ETYPE_ATTR_DOC[('SEDAKeywordReference', 'seda_keyword_reference_from', 'subject')] = ('KeywordReference', [u"Identifiant du mot cl\xe9 dans un r\xe9f\xe9rentiel donn\xe9. Par exemple, pour un lieu, il pourrait s'agir de son code officiel g\xe9ographique selon l'INSEE."])
ETYPE_ATTR_DOC[('SEDAKeyword', 'seda_keyword_reference_from', 'object')] = ('KeywordReference', [u"Identifiant du mot cl\xe9 dans un r\xe9f\xe9rentiel donn\xe9. Par exemple, pour un lieu, il pourrait s'agir de son code officiel g\xe9ographique selon l'INSEE."])
ETYPE_ATTR_DOC[('SEDAKeywordReference', 'seda_keyword_reference_to', 'subject')] = ('KeywordReference', [u"Identifiant du mot cl\xe9 dans un r\xe9f\xe9rentiel donn\xe9. Par exemple, pour un lieu, il pourrait s'agir de son code officiel g\xe9ographique selon l'INSEE."])
ETYPE_ATTR_DOC[('Concept', 'seda_keyword_reference_to', 'object')] = ('KeywordReference', [u"Identifiant du mot cl\xe9 dans un r\xe9f\xe9rentiel donn\xe9. Par exemple, pour un lieu, il pourrait s'agir de son code officiel g\xe9ographique selon l'INSEE."])
ETYPE_ATTR_DOC[('SEDAKeywordType', 'seda_keyword_type_from', 'subject')] = ('KeywordType', [u'Type de mot cl\xe9.'])
ETYPE_ATTR_DOC[('SEDAKeyword', 'seda_keyword_type_from', 'object')] = ('KeywordType', [u'Type de mot cl\xe9.'])
ETYPE_ATTR_DOC[('SEDAKeywordType', 'seda_keyword_type_to', 'subject')] = ('KeywordType', [u'Type de mot cl\xe9.'])
ETYPE_ATTR_DOC[('Concept', 'seda_keyword_type_to', 'object')] = ('KeywordType', [u'Type de mot cl\xe9.'])
ETYPE_ATTR_DOC[('SEDASpatial', 'seda_spatial', 'subject')] = ('Spatial', [u'Couverture spatiale ou couverture g\xe9ographique.', u'R\xe9f\xe9rences: AGKRMS.spatialCoverage'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_spatial', 'object')] = ('Spatial', [u'Couverture spatiale ou couverture g\xe9ographique.', u'R\xe9f\xe9rences: AGKRMS.spatialCoverage'])
ETYPE_ATTR_DOC[('SEDATemporal', 'seda_temporal', 'subject')] = ('Temporal', [u'Couverture temporelle.', u'R\xe9f\xe9rences: AGKRMS.temporalCoverage'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_temporal', 'object')] = ('Temporal', [u'Couverture temporelle.', u'R\xe9f\xe9rences: AGKRMS.temporalCoverage'])
ETYPE_ATTR_DOC[('SEDAJuridictional', 'seda_juridictional', 'subject')] = ('Juridictional', [u'Juridiction administrative ou ressort administratif.', u'R\xe9f\xe9rences: AGKRMS.juridictionalCoverage'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_juridictional', 'object')] = ('Juridictional', [u'Juridiction administrative ou ressort administratif.', u'R\xe9f\xe9rences: AGKRMS.juridictionalCoverage'])
ETYPE_ATTR_DOC[('SEDAIsVersionOf', 'seda_is_version_of', 'subject')] = ('IsVersionOf', [u"Est une version de. Edition, adaptation, traduction. Cette relation permet d'indiquer les modifications dans le contenu.", u'R\xe9f\xe9rences : DC.Relation.isVersionOf'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_is_version_of', 'object')] = ('IsVersionOf', [u"Est une version de. Edition, adaptation, traduction. Cette relation permet d'indiquer les modifications dans le contenu.", u'R\xe9f\xe9rences : DC.Relation.isVersionOf'])
ETYPE_ATTR_DOC[('SEDAReplaces', 'seda_replaces', 'subject')] = ('Replaces', [u"Remplace. Cette relation permet d'indiquer les objets remplac\xe9s par le niveau courant de description.", u'DC.Relation.replaces'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_replaces', 'object')] = ('Replaces', [u"Remplace. Cette relation permet d'indiquer les objets remplac\xe9s par le niveau courant de description.", u'DC.Relation.replaces'])
ETYPE_ATTR_DOC[('SEDARequires', 'seda_requires', 'subject')] = ('Requires', [u"Requiert. Cette relation permet d'indiquer les objets n\xe9cessaire \xe0 la compr\xe9hension du niveau courant de description.", u'R\xe9f\xe9rences : DC.Relation.requires'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_requires', 'object')] = ('Requires', [u"Requiert. Cette relation permet d'indiquer les objets n\xe9cessaire \xe0 la compr\xe9hension du niveau courant de description.", u'R\xe9f\xe9rences : DC.Relation.requires'])
ETYPE_ATTR_DOC[('SEDAIsPartOf', 'seda_is_part_of', 'subject')] = ('IsPartOf', [u"Est une partie de. Cette relation permet d'indique qu'un objet est une partie d'un autre.", u'R\xe9f\xe9rences : DC.Relation.isPartOf'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_is_part_of', 'object')] = ('IsPartOf', [u"Est une partie de. Cette relation permet d'indique qu'un objet est une partie d'un autre.", u'R\xe9f\xe9rences : DC.Relation.isPartOf'])
ETYPE_ATTR_DOC[('SEDAReferences', 'seda_references', 'subject')] = ('References', [u"R\xe9f\xe9rence. Cette relation permet d'indiquer qu'un objet en r\xe9f\xe9rence un autre.", u'DC.Relation.references'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_references', 'object')] = ('References', [u"R\xe9f\xe9rence. Cette relation permet d'indiquer qu'un objet en r\xe9f\xe9rence un autre.", u'DC.Relation.references'])
ETYPE_ATTR_DOC[('SEDAEventIdentifier', 'seda_event_identifier', 'subject')] = ('EventIdentifier', [u"Identifiant de l'\xe9v\xe9nement.", u'R\xe9f\xe9rences : premis.eventIdentifier'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_identifier', 'object')] = ('EventIdentifier', [u"Identifiant de l'\xe9v\xe9nement.", u'R\xe9f\xe9rences : premis.eventIdentifier'])
ETYPE_ATTR_DOC[('SEDAEventType', 'seda_event_type_from', 'subject')] = ('EventType', [u"Type d'\xe9v\xe9nement."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_type_from', 'object')] = ('EventType', [u"Type d'\xe9v\xe9nement."])
ETYPE_ATTR_DOC[('SEDAEventType', 'seda_event_type_to', 'subject')] = ('EventType', [u"Type d'\xe9v\xe9nement."])
ETYPE_ATTR_DOC[('Concept', 'seda_event_type_to', 'object')] = ('EventType', [u"Type d'\xe9v\xe9nement."])
ETYPE_ATTR_DOC[('SEDAEventDetail', 'seda_event_detail', 'subject')] = ('EventDetail', [u"D\xe9tail sur l'\xe9v\xe9nement."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_detail', 'object')] = ('EventDetail', [u"D\xe9tail sur l'\xe9v\xe9nement."])
ETYPE_ATTR_DOC[('SEDAGpsVersionID', 'seda_gps_version_id', 'subject')] = ('GpsVersionID', [u'Identifiant de la version du GPS.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_version_id', 'object')] = ('GpsVersionID', [u'Identifiant de la version du GPS.'])
ETYPE_ATTR_DOC[('SEDAGpsAltitude', 'seda_gps_altitude', 'subject')] = ('GpsAltitude', [u'Altitude de la position GPS.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_altitude', 'object')] = ('GpsAltitude', [u'Altitude de la position GPS.'])
ETYPE_ATTR_DOC[('SEDAGpsAltitudeRef', 'seda_gps_altitude_ref', 'subject')] = ('GpsAltitudeRef', [u'0 (niveau de la mer) / 1 (r\xe9f\xe9rence au niveau de la mer - valeur n\xe9gative -).'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_altitude_ref', 'object')] = ('GpsAltitudeRef', [u'0 (niveau de la mer) / 1 (r\xe9f\xe9rence au niveau de la mer - valeur n\xe9gative -).'])
ETYPE_ATTR_DOC[('SEDAGpsLatitude', 'seda_gps_latitude', 'subject')] = ('GpsLatitude', [u'N (Nord) /  S (Sud).'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_latitude', 'object')] = ('GpsLatitude', [u'N (Nord) /  S (Sud).'])
ETYPE_ATTR_DOC[('SEDAGpsLatitudeRef', 'seda_gps_latitude_ref', 'subject')] = ('GpsLatitudeRef', [])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_latitude_ref', 'object')] = ('GpsLatitudeRef', [])
ETYPE_ATTR_DOC[('SEDAGpsLongitude', 'seda_gps_longitude', 'subject')] = ('GpsLongitude', [u'Latitude de la position GPS.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_longitude', 'object')] = ('GpsLongitude', [u'Latitude de la position GPS.'])
ETYPE_ATTR_DOC[('SEDAGpsLongitudeRef', 'seda_gps_longitude_ref', 'subject')] = ('GpsLongitudeRef', [u'E (Est) / W (Ouest).'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_longitude_ref', 'object')] = ('GpsLongitudeRef', [u'E (Est) / W (Ouest).'])
ETYPE_ATTR_DOC[('SEDAGpsDateStamp', 'seda_gps_date_stamp', 'subject')] = ('GpsDateStamp', [u'Heure et Date de la position GPS.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_date_stamp', 'object')] = ('GpsDateStamp', [u'Heure et Date de la position GPS.'])
ETYPE_ATTR_DOC[('SEDAwhen', 'seda_when', 'subject')] = ('when', ())
ETYPE_ATTR_DOC[('SEDACustodialHistoryItem', 'seda_when', 'object')] = ('when', ())
ETYPE_ATTR_DOC[('SEDACustodialHistoryFile', 'seda_data_object_reference_id', 'subject')] = ('DataObjectReferenceId', [u'R\xe9f\xe9rence \xe0 un objet-donn\xe9es list\xe9 dans les m\xe9tadonn\xe9es de transport.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_data_object_reference_id', 'object')] = ('DataObjectReferenceId', [u'R\xe9f\xe9rence \xe0 un objet-donn\xe9es list\xe9 dans les m\xe9tadonn\xe9es de transport.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_data_object_reference_id', 'object')] = ('DataObjectReferenceId', [u'R\xe9f\xe9rence \xe0 un objet-donn\xe9es list\xe9 dans les m\xe9tadonn\xe9es de transport.'])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDAAltIsVersionOfArchiveUnitRefId', 'seda_data_object_reference', 'object')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDARepositoryArchiveUnitPID', 'seda_repository_archive_unit_pid', 'subject')] = ('RepositoryArchiveUnitPID', [u"R\xe9f\xe9rence \xe0 un ArchiveUnit d\xe9j\xe0 conserv\xe9 dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltReferencesArchiveUnitRefId', 'seda_repository_archive_unit_pid', 'object')] = ('RepositoryArchiveUnitPID', [u"R\xe9f\xe9rence \xe0 un ArchiveUnit d\xe9j\xe0 conserv\xe9 dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltIsPartOfArchiveUnitRefId', 'seda_repository_archive_unit_pid', 'object')] = ('RepositoryArchiveUnitPID', [u"R\xe9f\xe9rence \xe0 un ArchiveUnit d\xe9j\xe0 conserv\xe9 dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltRequiresArchiveUnitRefId', 'seda_repository_archive_unit_pid', 'object')] = ('RepositoryArchiveUnitPID', [u"R\xe9f\xe9rence \xe0 un ArchiveUnit d\xe9j\xe0 conserv\xe9 dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltReplacesArchiveUnitRefId', 'seda_repository_archive_unit_pid', 'object')] = ('RepositoryArchiveUnitPID', [u"R\xe9f\xe9rence \xe0 un ArchiveUnit d\xe9j\xe0 conserv\xe9 dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltIsVersionOfArchiveUnitRefId', 'seda_repository_archive_unit_pid', 'object')] = ('RepositoryArchiveUnitPID', [u"R\xe9f\xe9rence \xe0 un ArchiveUnit d\xe9j\xe0 conserv\xe9 dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDARepositoryObjectPID', 'seda_repository_object_pid', 'subject')] = ('RepositoryObjectPID', [u"R\xe9f\xe9rence \xe0 un un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es d\xe9j\xe0 conserv\xe9(s) dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltReferencesArchiveUnitRefId', 'seda_repository_object_pid', 'object')] = ('RepositoryObjectPID', [u"R\xe9f\xe9rence \xe0 un un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es d\xe9j\xe0 conserv\xe9(s) dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltIsPartOfArchiveUnitRefId', 'seda_repository_object_pid', 'object')] = ('RepositoryObjectPID', [u"R\xe9f\xe9rence \xe0 un un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es d\xe9j\xe0 conserv\xe9(s) dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltRequiresArchiveUnitRefId', 'seda_repository_object_pid', 'object')] = ('RepositoryObjectPID', [u"R\xe9f\xe9rence \xe0 un un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es d\xe9j\xe0 conserv\xe9(s) dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltReplacesArchiveUnitRefId', 'seda_repository_object_pid', 'object')] = ('RepositoryObjectPID', [u"R\xe9f\xe9rence \xe0 un un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es d\xe9j\xe0 conserv\xe9(s) dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltIsVersionOfArchiveUnitRefId', 'seda_repository_object_pid', 'object')] = ('RepositoryObjectPID', [u"R\xe9f\xe9rence \xe0 un un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es d\xe9j\xe0 conserv\xe9(s) dans un syst\xe8me d'archivage."])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDAAltReplacesArchiveUnitRefId', 'seda_data_object_reference', 'object')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDAAltRequiresArchiveUnitRefId', 'seda_data_object_reference', 'object')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDAAltIsPartOfArchiveUnitRefId', 'seda_data_object_reference', 'object')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
ETYPE_ATTR_DOC[('SEDAAltReferencesArchiveUnitRefId', 'seda_data_object_reference', 'object')] = ('DataObjectReference', [u"R\xe9f\xe9rence \xe0 un objet-donn\xe9es ou \xe0 un groupe d'objets-donn\xe9es interne(s)."])
