# -*- coding: utf-8 -*-
# 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.1 XSD FILES, DO NOT EDIT"""

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

ives = uicfg.indexview_etype_section
ives['SEDAMimeTypeCodeListVersion'] = 'subobject'
ives['SEDACustodialHistoryItem'] = 'subobject'
ives['SEDAAltReferencesArchiveUnitRefId'] = 'subobject'
ives['SEDALogBook'] = 'subobject'
ives['SEDAClassificationReassessingDate'] = 'subobject'
ives['SEDAOriginatingAgencyIdentifier'] = 'subobject'
ives['SEDADisseminationRuleCodeListVersion'] = 'subobject'
ives['SEDAAttachment'] = 'subobject'
ives['SEDAServiceLevel'] = 'subobject'
ives['SEDAArchivalProfile'] = 'subobject'
ives['SEDAEncoding'] = 'subobject'
ives['SEDASeqAltTransmitterCorpnameFirstName'] = 'subobject'
ives['SEDACorpname'] = 'subobject'
ives['SEDAIdentifier'] = 'subobject'
ives['SEDAAltRequiresArchiveUnitRefId'] = 'subobject'
ives['SEDABirthDate'] = 'subobject'
ives['SEDAPostalCode'] = 'subobject'
ives['SEDAReceivedDate'] = 'subobject'
ives['SEDARepositoryArchiveUnitPID'] = 'subobject'
ives['SEDASeqClassificationRuleRule'] = 'subobject'
ives['SEDAEventDetailData'] = 'subobject'
ives['SEDAPreventInheritance'] = 'subobject'
ives['SEDARelatedTransferReference'] = 'subobject'
ives['SEDALegalStatus'] = 'subobject'
ives['SEDATransactedDate'] = 'subobject'
ives['SEDAGpsLongitudeRef'] = 'subobject'
ives['SEDACountry'] = 'subobject'
ives['SEDATitle'] = 'subobject'
ives['SEDAArchivalAgreement'] = 'subobject'
ives['SEDAShape'] = 'subobject'
ives['SEDAGeogname'] = 'subobject'
ives['SEDAAgentAbstract'] = 'subobject'
ives['SEDADataObjectVersionCodeListVersion'] = 'subobject'
ives['SEDAUri'] = 'subobject'
ives['SEDAAltArchiveUnitArchiveUnitRefId'] = 'subobject'
ives['SEDAAcquisitionInformation'] = 'subobject'
ives['SEDAEventType'] = 'subobject'
ives['SEDADeathPlace'] = 'subobject'
ives['SEDAAccessRule'] = 'subobject'
ives['SEDARelationshipCodeListVersion'] = 'subobject'
ives['SEDASubmissionAgencyIdentifier'] = 'subobject'
ives['SEDASentDate'] = 'subobject'
ives['SEDARequires'] = 'subobject'
ives['SEDAEventIdentifier'] = 'subobject'
ives['SEDASpatial'] = 'subobject'
ives['SEDARefNonRuleId'] = 'subobject'
ives['SEDAWriter'] = 'subobject'
ives['SEDARelationship'] = 'subobject'
ives['SEDAOriginatingAgencyArchiveUnitIdentifier'] = 'subobject'
ives['SEDAStorageRuleCodeListVersion'] = 'subobject'
ives['SEDAAcquisitionInformationCodeListVersion'] = 'subobject'
ives['SEDAComment'] = 'subobject'
ives['SEDASeqAppraisalRuleRule'] = 'subobject'
ives['SEDACreatingOs'] = 'subobject'
ives['SEDAClassificationAudience'] = 'subobject'
ives['SEDAEventTypeCode'] = 'subobject'
ives['SEDAPosition'] = 'subobject'
ives['SEDAIsPartOf'] = 'subobject'
ives['SEDADataObjectGroupSystemId'] = 'subobject'
ives['SEDAArchiveUnit'] = 'subobject'
ives['SEDAGpsAltitudeRef'] = 'subobject'
ives['SEDASeqReuseRuleRule'] = 'subobject'
ives['SEDASystemId'] = 'subobject'
ives['SEDADateCreatedByApplication'] = 'subobject'
ives['SEDADataObjectVersion'] = 'subobject'
ives['SEDAAppraisalRule'] = 'subobject'
ives['SEDADepth'] = 'subobject'
ives['SEDADataObjectReferenceId'] = 'subobject'
ives['SEDAType'] = 'subobject'
ives['SEDAEncodingCodeListVersion'] = 'subobject'
ives['SEDAThickness'] = 'subobject'
ives['SEDASeqStorageRuleRule'] = 'subobject'
ives['SEDAStatus'] = 'subobject'
ives['SEDAAltIsPartOfArchiveUnitRefId'] = 'subobject'
ives['SEDACreatingApplicationVersion'] = 'subobject'
ives['SEDAAltStorageRulePreventInheritance'] = 'subobject'
ives['SEDAReplaces'] = 'subobject'
ives['SEDAOutcomeDetailMessage'] = 'subobject'
ives['SEDAStartDate'] = 'subobject'
ives['SEDASeqAltArchiveUnitArchiveUnitRefIdManagement'] = 'subobject'
ives['SEDAReuseRule'] = 'subobject'
ives['SEDAOriginatingSystemId'] = 'subobject'
ives['SEDAFormatId'] = 'subobject'
ives['SEDASender'] = 'subobject'
ives['SEDAwhen'] = 'subobject'
ives['SEDAAddress'] = 'subobject'
ives['SEDARegisteredDate'] = 'subobject'
ives['SEDANationality'] = 'subobject'
ives['SEDAArchiveUnitRefId'] = 'subobject'
ives['SEDADescriptionLevel'] = 'subobject'
ives['SEDALength'] = 'subobject'
ives['SEDAKeywordType'] = 'subobject'
ives['SEDAAuthorizedAgent'] = 'subobject'
ives['SEDAOutcome'] = 'subobject'
ives['SEDAEndDate'] = 'subobject'
ives['SEDAVersion'] = 'subobject'
ives['SEDAActivity'] = 'subobject'
ives['SEDAPhysicalDataObject'] = 'subobject'
ives['SEDADescriptionLanguage'] = 'subobject'
ives['SEDAAcquiredDate'] = 'subobject'
ives['SEDACompressionAlgorithmCodeListVersion'] = 'subobject'
ives['SEDAGpsLongitude'] = 'subobject'
ives['SEDACreatedDate'] = 'subobject'
ives['SEDACreatingOsVersion'] = 'subobject'
ives['SEDADeathDate'] = 'subobject'
ives['SEDATransferRequestReplyIdentifier'] = 'subobject'
ives['SEDASeqAltSenderCorpnameFirstName'] = 'subobject'
ives['SEDADataObjectGroup'] = 'subobject'
ives['SEDABinaryDataObject'] = 'subobject'
ives['SEDAFunction'] = 'subobject'
ives['SEDASignature'] = 'subobject'
ives['SEDATransferringAgencyArchiveUnitIdentifier'] = 'subobject'
ives['SEDAGivenName'] = 'subobject'
ives['SEDAExternalReference'] = 'subobject'
ives['SEDAPhysicalId'] = 'subobject'
ives['SEDAArchivalAgencyArchiveUnitIdentifier'] = 'subobject'
ives['SEDAAltTransmitterCorpname'] = 'subobject'
ives['SEDAGpsVersionID'] = 'subobject'
ives['SEDACreatingApplicationName'] = 'subobject'
ives['SEDAGpsAltitude'] = 'subobject'
ives['SEDAIsVersionOf'] = 'subobject'
ives['SEDADataObjectReference'] = 'subobject'
ives['SEDAHeight'] = 'subobject'
ives['SEDAMimeType'] = 'subobject'
ives['SEDAOutcomeDetail'] = 'subobject'
ives['SEDAFormatLitteral'] = 'subobject'
ives['SEDAStorageRule'] = 'subobject'
ives['SEDAKeywordReference'] = 'subobject'
ives['SEDAAltAgentAbstractCorpname'] = 'subobject'
ives['SEDARole'] = 'subobject'
ives['SEDARegion'] = 'subobject'
ives['SEDATransmitter'] = 'subobject'
ives['SEDASubmissionAgency'] = 'subobject'
ives['SEDAClassificationRuleCodeListVersion'] = 'subobject'
ives['SEDAReferences'] = 'subobject'
ives['SEDANeedReassessingAuthorization'] = 'subobject'
ives['SEDARecipient'] = 'subobject'
ives['SEDAWidth'] = 'subobject'
ives['SEDADescription'] = 'subobject'
ives['SEDAAltIsVersionOfArchiveUnitRefId'] = 'subobject'
ives['SEDANumberOfPage'] = 'subobject'
ives['SEDABirthName'] = 'subobject'
ives['SEDAClassificationRule'] = 'subobject'
ives['SEDAFileFormatCodeListVersion'] = 'subobject'
ives['SEDAEventAbstract'] = 'subobject'
ives['SEDAWeight'] = 'subobject'
ives['SEDADocumentType'] = 'subobject'
ives['SEDAFullName'] = 'subobject'
ives['SEDAGpsLatitude'] = 'subobject'
ives['SEDADisseminationRule'] = 'subobject'
ives['SEDAMessageDigestAlgorithmCodeListVersion'] = 'subobject'
ives['SEDAAccessRuleCodeListVersion'] = 'subobject'
ives['SEDAAltReuseRulePreventInheritance'] = 'subobject'
ives['SEDAAltReplacesArchiveUnitRefId'] = 'subobject'
ives['SEDAJuridictional'] = 'subobject'
ives['SEDARepositoryObjectPID'] = 'subobject'
ives['SEDATemporal'] = 'subobject'
ives['SEDAGpsDateStamp'] = 'subobject'
ives['SEDAReuseRuleCodeListVersion'] = 'subobject'
ives['SEDACustodialHistoryFile'] = 'subobject'
ives['SEDAEvent'] = 'subobject'
ives['SEDADataObjectSystemId'] = 'subobject'
ives['SEDANeedAuthorization'] = 'subobject'
ives['SEDAMandate'] = 'subobject'
ives['SEDAFirstName'] = 'subobject'
ives['SEDAGender'] = 'subobject'
ives['SEDACity'] = 'subobject'
ives['SEDASize'] = 'subobject'
ives['SEDAAltDisseminationRulePreventInheritance'] = 'subobject'
ives['SEDAGpsLatitudeRef'] = 'subobject'
ives['SEDAAltAppraisalRulePreventInheritance'] = 'subobject'
ives['SEDAAppraisalRuleCodeListVersion'] = 'subobject'
ives['SEDAKeyword'] = 'subobject'
ives['SEDAFilePlanPosition'] = 'subobject'
ives['SEDASeqDisseminationRuleRule'] = 'subobject'
ives['SEDATag'] = 'subobject'
ives['SEDAAddressee'] = 'subobject'
ives['SEDACompressed'] = 'subobject'
ives['SEDAAltAccessRulePreventInheritance'] = 'subobject'
ives['SEDAAltSenderCorpname'] = 'subobject'
ives['SEDAEventDetail'] = 'subobject'
ives['SEDAOriginatingAgency'] = 'subobject'
ives['SEDAAltClassificationRulePreventInheritance'] = 'subobject'
ives['SEDABirthPlace'] = 'subobject'
ives['SEDASource'] = 'subobject'
ives['SEDALastModified'] = 'subobject'
ives['SEDASeqAccessRuleRule'] = 'subobject'
ives['SEDASeqAltAgentAbstractCorpnameFirstName'] = 'subobject'
ives['SEDALanguage'] = 'subobject'
ives['SEDAAltBinaryDataObjectAttachment'] = 'subobject'
ives['SEDADiameter'] = '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_data_object_group', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_group', '*'), False)
abaa.tag_subject_of(('*', 'seda_physical_data_object', '*'), False)
abaa.tag_object_of(('*', 'seda_physical_data_object', '*'), False)
abaa.tag_subject_of(('*', 'seda_data_object_system_id', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_system_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_data_object_group_system_id', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_group_system_id', '*'), 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_size', '*'), False)
abaa.tag_object_of(('*', 'seda_size', '*'), False)
abaa.tag_subject_of(('*', 'seda_compressed', '*'), False)
abaa.tag_object_of(('*', 'seda_compressed', '*'), False)
abaa.tag_subject_of(('*', 'seda_log_book', '*'), False)
abaa.tag_object_of(('*', 'seda_log_book', '*'), False)
abaa.tag_subject_of(('*', 'seda_physical_id', '*'), False)
abaa.tag_object_of(('*', 'seda_physical_id', '*'), False)
abaa.tag_subject_of(('*', 'seda_archive_unit', '*'), False)
abaa.tag_object_of(('*', 'seda_archive_unit', '*'), False)
abaa.tag_subject_of(('*', 'seda_archival_profile', '*'), False)
abaa.tag_object_of(('*', 'seda_archival_profile', '*'), 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_target', '*'), False)
abaa.tag_subject_of(('*', 'seda_target', '*'), False)
abaa.tag_object_of(('*', 'seda_type_relationship', '*'), False)
abaa.tag_subject_of(('*', 'seda_type_relationship', '*'), 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_event', '*'), False)
abaa.tag_object_of(('*', 'seda_event', '*'), 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_subject_of(('*', 'seda_classification_audience', '*'), False)
abaa.tag_object_of(('*', 'seda_classification_audience', '*'), 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_event_identifier', '*'), False)
abaa.tag_object_of(('*', 'seda_event_identifier', '*'), False)
abaa.tag_subject_of(('*', 'seda_event_type_code', '*'), False)
abaa.tag_object_of(('*', 'seda_event_type_code', '*'), 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_outcome', '*'), False)
abaa.tag_object_of(('*', 'seda_outcome', '*'), False)
abaa.tag_subject_of(('*', 'seda_outcome_detail', '*'), False)
abaa.tag_object_of(('*', 'seda_outcome_detail', '*'), False)
abaa.tag_subject_of(('*', 'seda_outcome_detail_message', '*'), False)
abaa.tag_object_of(('*', 'seda_outcome_detail_message', '*'), False)
abaa.tag_subject_of(('*', 'seda_event_detail_data', '*'), False)
abaa.tag_object_of(('*', 'seda_event_detail_data', '*'), False)
abaa.tag_subject_of(('*', 'seda_event_abstract', '*'), False)
abaa.tag_object_of(('*', 'seda_event_abstract', '*'), False)
abaa.tag_subject_of(('*', 'seda_data_object_reference_id_from', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_reference_id_from', '*'), False)
abaa.tag_object_of(('*', 'seda_data_object_reference_id_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_data_object_reference_id_to', '*'), 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_subject_of(('*', 'seda_description_level_from', '*'), False)
abaa.tag_object_of(('*', 'seda_description_level_from', '*'), False)
abaa.tag_object_of(('*', 'seda_description_level_to', '*'), False)
abaa.tag_subject_of(('*', 'seda_description_level_to', '*'), 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_agent_abstract', '*'), False)
abaa.tag_object_of(('*', 'seda_agent_abstract', '*'), 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_transmitter', '*'), False)
abaa.tag_object_of(('*', 'seda_transmitter', '*'), False)
abaa.tag_subject_of(('*', 'seda_sender', '*'), False)
abaa.tag_object_of(('*', 'seda_sender', '*'), 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_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_object_of(('*', 'seda_alt_agent_abstract_corpname', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_agent_abstract_corpname', '*'), False)
abaa.tag_subject_of(('*', 'seda_identifier', '*'), False)
abaa.tag_object_of(('*', 'seda_identifier', '*'), False)
abaa.tag_subject_of(('*', 'seda_function', '*'), False)
abaa.tag_object_of(('*', 'seda_function', '*'), False)
abaa.tag_subject_of(('*', 'seda_activity', '*'), False)
abaa.tag_object_of(('*', 'seda_activity', '*'), False)
abaa.tag_subject_of(('*', 'seda_position', '*'), False)
abaa.tag_object_of(('*', 'seda_position', '*'), False)
abaa.tag_subject_of(('*', 'seda_role', '*'), False)
abaa.tag_object_of(('*', 'seda_role', '*'), False)
abaa.tag_subject_of(('*', 'seda_mandate', '*'), False)
abaa.tag_object_of(('*', 'seda_mandate', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_transmitter_corpname', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_transmitter_corpname', '*'), False)
abaa.tag_object_of(('*', 'seda_alt_sender_corpname', '*'), False)
abaa.tag_subject_of(('*', 'seda_alt_sender_corpname', '*'), 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_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_subject_of(('*', 'seda_corpname', '*'), False)
abaa.tag_object_of(('*', 'seda_corpname', '*'), False)
abaa.tag_object_of(('*', 'seda_seq_alt_agent_abstract_corpname_first_name', '*'), False)
abaa.tag_subject_of(('*', 'seda_seq_alt_agent_abstract_corpname_first_name', '*'), False)
abaa.tag_object_of(('*', 'seda_seq_alt_transmitter_corpname_first_name', '*'), False)
abaa.tag_subject_of(('*', 'seda_seq_alt_transmitter_corpname_first_name', '*'), False)
abaa.tag_object_of(('*', 'seda_seq_alt_sender_corpname_first_name', '*'), False)
abaa.tag_subject_of(('*', 'seda_seq_alt_sender_corpname_first_name', '*'), 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_first_name', '*'), False)
abaa.tag_object_of(('*', 'seda_first_name', '*'), False)
abaa.tag_subject_of(('*', 'seda_birth_name', '*'), False)
abaa.tag_object_of(('*', 'seda_birth_name', '*'), False)
abaa.tag_subject_of(('*', 'seda_full_name', '*'), False)
abaa.tag_object_of(('*', 'seda_full_name', '*'), False)
abaa.tag_subject_of(('*', 'seda_given_name', '*'), False)
abaa.tag_object_of(('*', 'seda_given_name', '*'), False)
abaa.tag_subject_of(('*', 'seda_gender', '*'), False)
abaa.tag_object_of(('*', 'seda_gender', '*'), False)
abaa.tag_subject_of(('*', 'seda_birth_date', '*'), False)
abaa.tag_object_of(('*', 'seda_birth_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_birth_place', '*'), False)
abaa.tag_object_of(('*', 'seda_birth_place', '*'), False)
abaa.tag_subject_of(('*', 'seda_death_date', '*'), False)
abaa.tag_object_of(('*', 'seda_death_date', '*'), False)
abaa.tag_subject_of(('*', 'seda_death_place', '*'), False)
abaa.tag_object_of(('*', 'seda_death_place', '*'), False)
abaa.tag_subject_of(('*', 'seda_nationality', '*'), False)
abaa.tag_object_of(('*', 'seda_nationality', '*'), False)
abaa.tag_subject_of(('*', 'seda_external_reference', '*'), False)
abaa.tag_object_of(('*', 'seda_external_reference', '*'), 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)
abaa.tag_subject_of(('*', 'seda_address', '*'), False)
abaa.tag_object_of(('*', 'seda_address', '*'), False)
abaa.tag_subject_of(('*', 'seda_city', '*'), False)
abaa.tag_object_of(('*', 'seda_city', '*'), False)
abaa.tag_subject_of(('*', 'seda_country', '*'), False)
abaa.tag_object_of(('*', 'seda_country', '*'), False)
abaa.tag_subject_of(('*', 'seda_geogname', '*'), False)
abaa.tag_object_of(('*', 'seda_geogname', '*'), False)
abaa.tag_subject_of(('*', 'seda_postal_code', '*'), False)
abaa.tag_object_of(('*', 'seda_postal_code', '*'), False)
abaa.tag_subject_of(('*', 'seda_region', '*'), False)
abaa.tag_object_of(('*', 'seda_region', '*'), 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', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'archival_profile', '*'), {'widget': fw.TextInput({'size': 80})})
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})})
affk.tag_subject_of(('*', 'function', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'activity', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'position', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'role', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'mandate', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'corpname', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'first_name', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'birth_name', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'full_name', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'given_name', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'address', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'city', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'country', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'geogname', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'postal_code', '*'), {'widget': fw.TextInput({'size': 80})})
affk.tag_subject_of(('*', 'region', '*'), {'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_data_object_group', '*'), '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_data_object_system_id', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_data_object_system_id', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_data_object_group_system_id', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_data_object_group_system_id', '*'), 'main', 'inlined')
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_size', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_size', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_compressed', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_compressed', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_log_book', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_log_book', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_physical_id', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_physical_id', '*'), '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_archival_profile', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_archival_profile', '*'), 'main', 'inlined')
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_target', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_target', '*'), 'main', 'attributes')
afs.tag_object_of(('*', 'seda_type_relationship', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_type_relationship', '*'), '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_event', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_event', '*'), 'main', 'inlined')
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_subject_of(('*', 'seda_classification_audience', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_classification_audience', '*'), '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_event_identifier', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_event_identifier', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_event_type_code', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_event_type_code', '*'), '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_outcome', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_outcome', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_outcome_detail', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_outcome_detail', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_outcome_detail_message', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_outcome_detail_message', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_event_detail_data', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_event_detail_data', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_event_abstract', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_event_abstract', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_data_object_reference_id_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_data_object_reference_id_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_data_object_reference_id_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_data_object_reference_id_to', '*'), 'main', 'attributes')
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_subject_of(('*', 'seda_description_level_from', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_description_level_from', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_description_level_to', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_description_level_to', '*'), '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_agent_abstract', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_agent_abstract', '*'), 'main', 'inlined')
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_transmitter', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_transmitter', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_sender', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_sender', '*'), 'main', 'inlined')
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_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_object_of(('*', 'seda_alt_agent_abstract_corpname', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_agent_abstract_corpname', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_identifier', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_identifier', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_function', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_function', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_activity', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_activity', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_position', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_position', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_role', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_role', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_mandate', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_mandate', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_transmitter_corpname', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_transmitter_corpname', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_alt_sender_corpname', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_alt_sender_corpname', '*'), 'main', 'inlined')
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_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_subject_of(('*', 'seda_corpname', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_corpname', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_seq_alt_agent_abstract_corpname_first_name', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_seq_alt_agent_abstract_corpname_first_name', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_seq_alt_transmitter_corpname_first_name', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_seq_alt_transmitter_corpname_first_name', '*'), 'main', 'inlined')
afs.tag_object_of(('*', 'seda_seq_alt_sender_corpname_first_name', '*'), 'main', 'hidden')
afs.tag_subject_of(('*', 'seda_seq_alt_sender_corpname_first_name', '*'), '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_first_name', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_first_name', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_birth_name', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_birth_name', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_full_name', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_full_name', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_given_name', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_given_name', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_gender', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_gender', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_birth_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_birth_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_birth_place', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_birth_place', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_death_date', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_death_date', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_death_place', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_death_place', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_nationality', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_nationality', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_external_reference', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_external_reference', '*'), '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')
afs.tag_subject_of(('*', 'seda_address', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_address', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_city', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_city', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_country', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_country', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_geogname', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_geogname', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_postal_code', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_postal_code', '*'), 'main', 'inlined')
afs.tag_subject_of(('*', 'seda_region', '*'), 'main', 'hidden')
afs.tag_object_of(('*', 'seda_region', '*'), 'main', 'inlined')

#seda 2.1

afs.tag_object_of(('*', 'seda_agent_abstract', '*'), 'main', 'hidden')

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_event_type_to', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_unit', '*'), 'hidden')
pvs.tag_object_of(('*', 'seda_description_level_to', '*'), '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_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_system_id', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_data_object_group_system_id', '*'), {'novalue_label': ' '})
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': ' '})
rec.tag_object_of(('*', 'seda_size', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'compressed', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_compressed', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_log_book', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_physical_id', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'archival_profile', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_archival_profile', '*'), {'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_target', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_type_relationship', '*'), {'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_object_of(('*', 'seda_classification_audience', '*'), {'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_object_of(('*', 'seda_event_identifier', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_event_type_code', '*'), {'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_outcome', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_outcome_detail', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_outcome_detail_message', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_event_detail_data', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_data_object_reference_id_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_data_object_reference_id_to', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_unit', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_description_level_from', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_description_level_to', '*'), {'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_subject_of(('*', 'archival_agency_archive_unit_identifier', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'originating_agency_archive_unit_identifier', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'transferring_agency_archive_unit_identifier', '*'), {'novalue_label': '<no value specified>'})
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_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_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_subject_of(('*', 'seda_alt_agent_abstract_corpname', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'function', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'activity', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'position', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'role', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'mandate', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_alt_transmitter_corpname', '*'), {'novalue_label': '<no value specified>'})
rec.tag_subject_of(('*', 'seda_alt_sender_corpname', '*'), {'novalue_label': '<no value specified>'})
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(('*', 'corpname', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_corpname', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_seq_alt_agent_abstract_corpname_first_name', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_seq_alt_transmitter_corpname_first_name', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'seda_seq_alt_sender_corpname_first_name', '*'), {'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_subject_of(('*', 'first_name', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_first_name', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'birth_name', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_birth_name', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'full_name', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_full_name', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'given_name', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_given_name', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_gender', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'birth_date', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_birth_date', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_birth_place', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'death_date', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_death_date', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_death_place', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_external_reference', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_repository_archive_unit_pid', '*'), {'novalue_label': ' '})
rec.tag_object_of(('*', 'seda_repository_object_pid', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'address', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_address', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'city', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_city', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'country', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_country', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'geogname', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_geogname', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'postal_code', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_postal_code', '*'), {'novalue_label': ' '})
rec.tag_subject_of(('*', 'region', '*'), {'novalue_label': '<no value specified>'})
rec.tag_object_of(('*', 'seda_region', '*'), {'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('SEDAArchivalProfile', ['user_cardinality', 'archival_profile', 'user_annotation'])
pvds.set_fields_order('SEDAArchivalProfile', ['user_cardinality', 'archival_profile', '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'])
affk.set_fields_order('SEDAFunction', ['user_cardinality', 'function', 'user_annotation'])
pvds.set_fields_order('SEDAFunction', ['user_cardinality', 'function', 'user_annotation'])
affk.set_fields_order('SEDAActivity', ['user_cardinality', 'activity', 'user_annotation'])
pvds.set_fields_order('SEDAActivity', ['user_cardinality', 'activity', 'user_annotation'])
affk.set_fields_order('SEDAPosition', ['user_cardinality', 'position', 'user_annotation'])
pvds.set_fields_order('SEDAPosition', ['user_cardinality', 'position', 'user_annotation'])
affk.set_fields_order('SEDARole', ['user_cardinality', 'role', 'user_annotation'])
pvds.set_fields_order('SEDARole', ['user_cardinality', 'role', 'user_annotation'])
affk.set_fields_order('SEDAMandate', ['user_cardinality', 'mandate', 'user_annotation'])
pvds.set_fields_order('SEDAMandate', ['user_cardinality', 'mandate', 'user_annotation'])
affk.set_fields_order('SEDAFirstName', ['user_cardinality', 'first_name', 'user_annotation'])
pvds.set_fields_order('SEDAFirstName', ['user_cardinality', 'first_name', 'user_annotation'])
affk.set_fields_order('SEDABirthName', ['user_cardinality', 'birth_name', 'user_annotation'])
pvds.set_fields_order('SEDABirthName', ['user_cardinality', 'birth_name', 'user_annotation'])
affk.set_fields_order('SEDAFullName', ['user_cardinality', 'full_name', 'user_annotation'])
pvds.set_fields_order('SEDAFullName', ['user_cardinality', 'full_name', 'user_annotation'])
affk.set_fields_order('SEDAGivenName', ['user_cardinality', 'given_name', 'user_annotation'])
pvds.set_fields_order('SEDAGivenName', ['user_cardinality', 'given_name', 'user_annotation'])
affk.set_fields_order('SEDABirthDate', ['user_cardinality', 'birth_date', 'user_annotation'])
pvds.set_fields_order('SEDABirthDate', ['user_cardinality', 'birth_date', 'user_annotation'])
affk.set_fields_order('SEDADeathDate', ['user_cardinality', 'death_date', 'user_annotation'])
pvds.set_fields_order('SEDADeathDate', ['user_cardinality', 'death_date', 'user_annotation'])
affk.set_fields_order('SEDAAddress', ['user_cardinality', 'address', 'user_annotation'])
pvds.set_fields_order('SEDAAddress', ['user_cardinality', 'address', 'user_annotation'])
affk.set_fields_order('SEDACity', ['user_cardinality', 'city', 'user_annotation'])
pvds.set_fields_order('SEDACity', ['user_cardinality', 'city', 'user_annotation'])
affk.set_fields_order('SEDACountry', ['user_cardinality', 'country', 'user_annotation'])
pvds.set_fields_order('SEDACountry', ['user_cardinality', 'country', 'user_annotation'])
affk.set_fields_order('SEDAGeogname', ['user_cardinality', 'geogname', 'user_annotation'])
pvds.set_fields_order('SEDAGeogname', ['user_cardinality', 'geogname', 'user_annotation'])
affk.set_fields_order('SEDAPostalCode', ['user_cardinality', 'postal_code', 'user_annotation'])
pvds.set_fields_order('SEDAPostalCode', ['user_cardinality', 'postal_code', 'user_annotation'])
affk.set_fields_order('SEDARegion', ['user_cardinality', 'region', 'user_annotation'])
pvds.set_fields_order('SEDARegion', ['user_cardinality', 'region', 'user_annotation'])

ETYPE_ATTR_DOC = {}
ETYPE_ATTR_DOC[('SEDAComment', 'seda_comment', 'subject')] = ('Comment', ['Commentaire sur le message.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_comment', 'object')] = ('Comment', ['Commentaire sur le message.'])
ETYPE_ATTR_DOC[('SEDASignature', 'seda_signature', 'subject')] = ('Signature', ['Signature du message.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_signature', 'object')] = ('Signature', ['Signature du message.'])
ETYPE_ATTR_DOC[('SEDAArchivalAgreement', 'seda_archival_agreement', 'subject')] = ('ArchivalAgreement', ['Accord de service.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_archival_agreement', 'object')] = ('ArchivalAgreement', ['Accord de service.'])
ETYPE_ATTR_DOC[('SEDARelatedTransferReference', 'seda_related_transfer_reference', 'subject')] = ('RelatedTransferReference', ['Identifiant d’un transfert\n                                associé.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_related_transfer_reference', 'object')] = ('RelatedTransferReference', ['Identifiant d’un transfert\n                                associé.'])
ETYPE_ATTR_DOC[('SEDATransferRequestReplyIdentifier', 'seda_transfer_request_reply_identifier', 'subject')] = ('TransferRequestReplyIdentifier', ['Identifiant de la réponse à une demande de\n                                transfert.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_transfer_request_reply_identifier', 'object')] = ('TransferRequestReplyIdentifier', ['Identifiant de la réponse à une demande de\n                                transfert.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_archival_agency', 'subject')] = ('ArchivalAgency', ["Service d'archives responsable de la\n                                communication."])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_archival_agency', 'object')] = ('ArchivalAgency', ["Service d'archives responsable de la\n                                communication."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_transferring_agency', 'subject')] = ('TransferringAgency', ['Service versant chargé de réaliser le\n                                transport.'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_transferring_agency', 'object')] = ('TransferringAgency', ['Service versant chargé de réaliser le\n                                transport.'])
ETYPE_ATTR_DOC[('SEDAMessageDigestAlgorithmCodeListVersion', 'seda_message_digest_algorithm_code_list_version_from', 'subject')] = ('MessageDigestAlgorithmCodeListVersion', ["Liste de l'algorithme de hachage utilisé dans le message."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_message_digest_algorithm_code_list_version_from', 'object')] = ('MessageDigestAlgorithmCodeListVersion', ["Liste de l'algorithme de hachage utilisé dans le message."])
ETYPE_ATTR_DOC[('SEDAMessageDigestAlgorithmCodeListVersion', 'seda_message_digest_algorithm_code_list_version_to', 'subject')] = ('MessageDigestAlgorithmCodeListVersion', ["Liste de l'algorithme de hachage utilisé dans le message."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_message_digest_algorithm_code_list_version_to', 'object')] = ('MessageDigestAlgorithmCodeListVersion', ["Liste de l'algorithme de hachage utilisé dans le message."])
ETYPE_ATTR_DOC[('SEDAMimeTypeCodeListVersion', 'seda_mime_type_code_list_version_from', 'subject')] = ('MimeTypeCodeListVersion', ['Version de la liste de code du type Mime.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_mime_type_code_list_version_from', 'object')] = ('MimeTypeCodeListVersion', ['Version de la liste de code du type Mime.'])
ETYPE_ATTR_DOC[('SEDAMimeTypeCodeListVersion', 'seda_mime_type_code_list_version_to', 'subject')] = ('MimeTypeCodeListVersion', ['Version de la liste de code du type Mime.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_mime_type_code_list_version_to', 'object')] = ('MimeTypeCodeListVersion', ['Version de la liste de code du type Mime.'])
ETYPE_ATTR_DOC[('SEDAEncodingCodeListVersion', 'seda_encoding_code_list_version_from', 'subject')] = ('EncodingCodeListVersion', ["Version de la liste de code d'encodage du\n                        fichier."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_encoding_code_list_version_from', 'object')] = ('EncodingCodeListVersion', ["Version de la liste de code d'encodage du\n                        fichier."])
ETYPE_ATTR_DOC[('SEDAEncodingCodeListVersion', 'seda_encoding_code_list_version_to', 'subject')] = ('EncodingCodeListVersion', ["Version de la liste de code d'encodage du\n                        fichier."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_encoding_code_list_version_to', 'object')] = ('EncodingCodeListVersion', ["Version de la liste de code d'encodage du\n                        fichier."])
ETYPE_ATTR_DOC[('SEDAFileFormatCodeListVersion', 'seda_file_format_code_list_version_from', 'subject')] = ('FileFormatCodeListVersion', ["Version de la liste de code d'identification du format."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_file_format_code_list_version_from', 'object')] = ('FileFormatCodeListVersion', ["Version de la liste de code d'identification du format."])
ETYPE_ATTR_DOC[('SEDAFileFormatCodeListVersion', 'seda_file_format_code_list_version_to', 'subject')] = ('FileFormatCodeListVersion', ["Version de la liste de code d'identification du format."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_file_format_code_list_version_to', 'object')] = ('FileFormatCodeListVersion', ["Version de la liste de code d'identification du format."])
ETYPE_ATTR_DOC[('SEDACompressionAlgorithmCodeListVersion', 'seda_compression_algorithm_code_list_version_from', 'subject')] = ('CompressionAlgorithmCodeListVersion', ["Version de la liste de code de l'algorithme de compression."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_compression_algorithm_code_list_version_from', 'object')] = ('CompressionAlgorithmCodeListVersion', ["Version de la liste de code de l'algorithme de compression."])
ETYPE_ATTR_DOC[('SEDACompressionAlgorithmCodeListVersion', 'seda_compression_algorithm_code_list_version_to', 'subject')] = ('CompressionAlgorithmCodeListVersion', ["Version de la liste de code de l'algorithme de compression."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_compression_algorithm_code_list_version_to', 'object')] = ('CompressionAlgorithmCodeListVersion', ["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', ["Liste de codes correspondant aux diverses versions d'un objet-données au sein d’un groupe d'objets-données (ex. original papier, conservation, diffusion, vignette, txt)."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_data_object_version_code_list_version_from', 'object')] = ('DataObjectVersionCodeListVersion', ["Liste de codes correspondant aux diverses versions d'un objet-données au sein d’un groupe d'objets-données (ex. original papier, conservation, diffusion, vignette, txt)."])
ETYPE_ATTR_DOC[('SEDADataObjectVersionCodeListVersion', 'seda_data_object_version_code_list_version_to', 'subject')] = ('DataObjectVersionCodeListVersion', ["Liste de codes correspondant aux diverses versions d'un objet-données au sein d’un groupe d'objets-données (ex. original papier, conservation, diffusion, vignette, txt)."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_data_object_version_code_list_version_to', 'object')] = ('DataObjectVersionCodeListVersion', ["Liste de codes correspondant aux diverses versions d'un objet-données au sein d’un groupe d'objets-données (ex. original papier, conservation, diffusion, vignette, txt)."])
ETYPE_ATTR_DOC[('SEDAStorageRuleCodeListVersion', 'seda_storage_rule_code_list_version_from', 'subject')] = ('StorageRuleCodeListVersion', ["Version des listes de codes pour les règles de durée d'utilité courante."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_storage_rule_code_list_version_from', 'object')] = ('StorageRuleCodeListVersion', ["Version des listes de codes pour les règles de durée d'utilité courante."])
ETYPE_ATTR_DOC[('SEDAStorageRuleCodeListVersion', 'seda_storage_rule_code_list_version_to', 'subject')] = ('StorageRuleCodeListVersion', ["Version des listes de codes pour les règles de durée d'utilité courante."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_storage_rule_code_list_version_to', 'object')] = ('StorageRuleCodeListVersion', ["Version des listes de codes pour les règles de durée d'utilité courante."])
ETYPE_ATTR_DOC[('SEDAAppraisalRuleCodeListVersion', 'seda_appraisal_rule_code_list_version_from', 'subject')] = ('AppraisalRuleCodeListVersion', ["Version des listes de codes pour les règles de durée d'utilité administrative."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_appraisal_rule_code_list_version_from', 'object')] = ('AppraisalRuleCodeListVersion', ["Version des listes de codes pour les règles de durée d'utilité administrative."])
ETYPE_ATTR_DOC[('SEDAAppraisalRuleCodeListVersion', 'seda_appraisal_rule_code_list_version_to', 'subject')] = ('AppraisalRuleCodeListVersion', ["Version des listes de codes pour les règles de durée d'utilité administrative."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_appraisal_rule_code_list_version_to', 'object')] = ('AppraisalRuleCodeListVersion', ["Version des listes de codes pour les règles de durée d'utilité administrative."])
ETYPE_ATTR_DOC[('SEDAAccessRuleCodeListVersion', 'seda_access_rule_code_list_version_from', 'subject')] = ('AccessRuleCodeListVersion', ['Version des listes de codes pour les règles de communicabilité.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_access_rule_code_list_version_from', 'object')] = ('AccessRuleCodeListVersion', ['Version des listes de codes pour les règles de communicabilité.'])
ETYPE_ATTR_DOC[('SEDAAccessRuleCodeListVersion', 'seda_access_rule_code_list_version_to', 'subject')] = ('AccessRuleCodeListVersion', ['Version des listes de codes pour les règles de communicabilité.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_access_rule_code_list_version_to', 'object')] = ('AccessRuleCodeListVersion', ['Version des listes de codes pour les règles de communicabilité.'])
ETYPE_ATTR_DOC[('SEDADisseminationRuleCodeListVersion', 'seda_dissemination_rule_code_list_version_from', 'subject')] = ('DisseminationRuleCodeListVersion', ['Version des listes de codes pour les règles de diffusion.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_dissemination_rule_code_list_version_from', 'object')] = ('DisseminationRuleCodeListVersion', ['Version des listes de codes pour les règles de diffusion.'])
ETYPE_ATTR_DOC[('SEDADisseminationRuleCodeListVersion', 'seda_dissemination_rule_code_list_version_to', 'subject')] = ('DisseminationRuleCodeListVersion', ['Version des listes de codes pour les règles de diffusion.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_dissemination_rule_code_list_version_to', 'object')] = ('DisseminationRuleCodeListVersion', ['Version des listes de codes pour les règles de diffusion.'])
ETYPE_ATTR_DOC[('SEDAReuseRuleCodeListVersion', 'seda_reuse_rule_code_list_version_from', 'subject')] = ('ReuseRuleCodeListVersion', ['Version des listes de codes pour les règles de réutilisation.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_reuse_rule_code_list_version_from', 'object')] = ('ReuseRuleCodeListVersion', ['Version des listes de codes pour les règles de réutilisation.'])
ETYPE_ATTR_DOC[('SEDAReuseRuleCodeListVersion', 'seda_reuse_rule_code_list_version_to', 'subject')] = ('ReuseRuleCodeListVersion', ['Version des listes de codes pour les règles de réutilisation.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_reuse_rule_code_list_version_to', 'object')] = ('ReuseRuleCodeListVersion', ['Version des listes de codes pour les règles de réutilisation.'])
ETYPE_ATTR_DOC[('SEDAClassificationRuleCodeListVersion', 'seda_classification_rule_code_list_version_from', 'subject')] = ('ClassificationRuleCodeListVersion', ['Version des listes de codes pour les règles de classification.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_classification_rule_code_list_version_from', 'object')] = ('ClassificationRuleCodeListVersion', ['Version des listes de codes pour les règles de classification.'])
ETYPE_ATTR_DOC[('SEDAClassificationRuleCodeListVersion', 'seda_classification_rule_code_list_version_to', 'subject')] = ('ClassificationRuleCodeListVersion', ['Version des listes de codes pour les règles de classification.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_classification_rule_code_list_version_to', 'object')] = ('ClassificationRuleCodeListVersion', ['Version des listes de codes pour les règles de classification.'])
ETYPE_ATTR_DOC[('SEDAAcquisitionInformationCodeListVersion', 'seda_acquisition_information_code_list_version_from', 'subject')] = ('AcquisitionInformationCodeListVersion', ["Version de la liste de codes des modalités\n                        d'entrée."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_acquisition_information_code_list_version_from', 'object')] = ('AcquisitionInformationCodeListVersion', ["Version de la liste de codes des modalités\n                        d'entrée."])
ETYPE_ATTR_DOC[('SEDAAcquisitionInformationCodeListVersion', 'seda_acquisition_information_code_list_version_to', 'subject')] = ('AcquisitionInformationCodeListVersion', ["Version de la liste de codes des modalités\n                        d'entrée."])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_acquisition_information_code_list_version_to', 'object')] = ('AcquisitionInformationCodeListVersion', ["Version de la liste de codes des modalités\n                        d'entrée."])
ETYPE_ATTR_DOC[('SEDARelationshipCodeListVersion', 'seda_relationship_code_list_version_from', 'subject')] = ('RelationshipCodeListVersion', ['Version de la liste de codes des\n                        relations.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_relationship_code_list_version_from', 'object')] = ('RelationshipCodeListVersion', ['Version de la liste de codes des\n                        relations.'])
ETYPE_ATTR_DOC[('SEDARelationshipCodeListVersion', 'seda_relationship_code_list_version_to', 'subject')] = ('RelationshipCodeListVersion', ['Version de la liste de codes des\n                        relations.'])
ETYPE_ATTR_DOC[('ConceptScheme', 'seda_relationship_code_list_version_to', 'object')] = ('RelationshipCodeListVersion', ['Version de la liste de codes des\n                        relations.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_binary_data_object', 'subject')] = ('BinaryDataObject', ["Bloc de métadonnées techniques des objets-données\n                            numériques. Le caractère facultatif est requis afin de permettre le\n                            transfert d'un plan de classement sans DataObject\n                            joint."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_binary_data_object', 'object')] = ('BinaryDataObject', ["Bloc de métadonnées techniques des objets-données\n                            numériques. Le caractère facultatif est requis afin de permettre le\n                            transfert d'un plan de classement sans DataObject\n                            joint."])
ETYPE_ATTR_DOC[('SEDADataObjectGroup', 'seda_data_object_group', 'subject')] = ('DataObjectGroup', [])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_data_object_group', 'object')] = ('DataObjectGroup', [])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_physical_data_object', 'subject')] = ('PhysicalDataObject', ['Bloc de métadonnées techniques des objets-données\n                            physiques.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_physical_data_object', 'object')] = ('PhysicalDataObject', ['Bloc de métadonnées techniques des objets-données\n                            physiques.'])
ETYPE_ATTR_DOC[('SEDADataObjectSystemId', 'seda_data_object_system_id', 'subject')] = ('DataObjectSystemId', ['Identifiant attribué aux objets de données. Il est attribué par le SAE et correspond à un identifiant interne.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_data_object_system_id', 'object')] = ('DataObjectSystemId', ['Identifiant attribué aux objets de données. Il est attribué par le SAE et correspond à un identifiant interne.'])
ETYPE_ATTR_DOC[('SEDADataObjectGroupSystemId', 'seda_data_object_group_system_id', 'subject')] = ('DataObjectGroupSystemId', ["Identifiant attribué aux groupes d'objets de données. Il est attribué par le SAE et correspond à un identifiant interne."])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_data_object_group_system_id', 'object')] = ('DataObjectGroupSystemId', ["Identifiant attribué aux groupes d'objets de données. Il est attribué par le SAE et correspond à un identifiant interne."])
ETYPE_ATTR_DOC[('SEDARelationship', 'seda_relationship', 'subject')] = ('Relationship', ['Permet de spécifier un lien technique entre un objet-données et une signature.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_relationship', 'object')] = ('Relationship', ['Permet de spécifier un lien technique entre un objet-données et une signature.'])
ETYPE_ATTR_DOC[('SEDADataObjectVersion', 'seda_data_object_version_from', 'subject')] = ('DataObjectVersion', ['Version d’un objet-données (par exemple : original papier, conservation, diffusion, vignette, txt, …).'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_data_object_version_from', 'object')] = ('DataObjectVersion', ['Version d’un objet-données (par exemple : original papier, conservation, diffusion, vignette, txt, …).'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_data_object_version_from', 'object')] = ('DataObjectVersion', ['Version d’un objet-données (par exemple : original papier, conservation, diffusion, vignette, txt, …).'])
ETYPE_ATTR_DOC[('SEDADataObjectVersion', 'seda_data_object_version_to', 'subject')] = ('DataObjectVersion', ['Version d’un objet-données (par exemple : original papier, conservation, diffusion, vignette, txt, …).'])
ETYPE_ATTR_DOC[('Concept', 'seda_data_object_version_to', 'object')] = ('DataObjectVersion', ['Version d’un objet-données (par exemple : original papier, conservation, diffusion, vignette, txt, …).'])
ETYPE_ATTR_DOC[('SEDASize', 'seda_size', 'subject')] = ('Size', ["Permet de spécifier la taille de l'objet-données en octet."])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_size', 'object')] = ('Size', ["Permet de spécifier la taille de l'objet-données en octet."])
ETYPE_ATTR_DOC[('SEDACompressed', 'seda_compressed', 'subject')] = ('Compressed', ['Indique si l’objet-données est compressé et doit être décompressé.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_compressed', 'object')] = ('Compressed', ['Indique si l’objet-données est compressé et doit être décompressé.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_binary_data_object', 'subject')] = ('BinaryDataObject', ["Bloc de métadonnées techniques des objets-données\n                            numériques. Le caractère facultatif est requis afin de permettre le\n                            transfert d'un plan de classement sans DataObject\n                            joint."])
ETYPE_ATTR_DOC[('SEDADataObjectGroup', 'seda_binary_data_object', 'object')] = ('BinaryDataObject', ["Bloc de métadonnées techniques des objets-données\n                            numériques. Le caractère facultatif est requis afin de permettre le\n                            transfert d'un plan de classement sans DataObject\n                            joint."])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_physical_data_object', 'subject')] = ('PhysicalDataObject', ['Bloc de métadonnées techniques des objets-données\n                            physiques.'])
ETYPE_ATTR_DOC[('SEDADataObjectGroup', 'seda_physical_data_object', 'object')] = ('PhysicalDataObject', ['Bloc de métadonnées techniques des objets-données\n                            physiques.'])
ETYPE_ATTR_DOC[('SEDALogBook', 'seda_log_book', 'subject')] = ('LogBook', [])
ETYPE_ATTR_DOC[('SEDADataObjectGroup', 'seda_log_book', 'object')] = ('LogBook', [])
ETYPE_ATTR_DOC[('SEDADataObjectSystemId', 'seda_data_object_system_id', 'subject')] = ('DataObjectSystemId', ['Identifiant attribué aux objets de données. Il est attribué par le SAE et correspond à un identifiant interne.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_data_object_system_id', 'object')] = ('DataObjectSystemId', ['Identifiant attribué aux objets de données. Il est attribué par le SAE et correspond à un identifiant interne.'])
ETYPE_ATTR_DOC[('SEDADataObjectGroupSystemId', 'seda_data_object_group_system_id', 'subject')] = ('DataObjectGroupSystemId', ["Identifiant attribué aux groupes d'objets de données. Il est attribué par le SAE et correspond à un identifiant interne."])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_data_object_group_system_id', 'object')] = ('DataObjectGroupSystemId', ["Identifiant attribué aux groupes d'objets de données. Il est attribué par le SAE et correspond à un identifiant interne."])
ETYPE_ATTR_DOC[('SEDARelationship', 'seda_relationship', 'subject')] = ('Relationship', ['Permet de spécifier un lien technique entre un objet-données et une signature.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_relationship', 'object')] = ('Relationship', ['Permet de spécifier un lien technique entre un objet-données et une signature.'])
ETYPE_ATTR_DOC[('SEDAPhysicalId', 'seda_physical_id', 'subject')] = ('PhysicalId', ['Identifiant physique d’un objet-données physique, externe à celui-ci (ex. code-barres).'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_physical_id', 'object')] = ('PhysicalId', ['Identifiant physique d’un objet-données physique, externe à celui-ci (ex. code-barres).'])
ETYPE_ATTR_DOC[('SEDAArchiveUnit', 'seda_archive_unit', 'subject')] = ('ArchiveUnit', ['Correspond à la notion de composant en ISAD(G). ArchiveUnit\n                        permet à la fois de gérer la hiérarchie intellectuelle, tout en contenant\n                        les métadonnées de description et de gestion propres à chaque niveau de\n                        description archivistique.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_archive_unit', 'object')] = ('ArchiveUnit', ['Correspond à la notion de composant en ISAD(G). ArchiveUnit\n                        permet à la fois de gérer la hiérarchie intellectuelle, tout en contenant\n                        les métadonnées de description et de gestion propres à chaque niveau de\n                        description archivistique.'])
ETYPE_ATTR_DOC[('SEDAArchivalProfile', 'seda_archival_profile', 'subject')] = ('ArchivalProfile', ['Profil d’archivage applicable aux\n                        ArchiveUnit.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_archival_profile', 'object')] = ('ArchivalProfile', ['Profil d’archivage applicable aux\n                        ArchiveUnit.'])
ETYPE_ATTR_DOC[('SEDAServiceLevel', 'seda_service_level', 'subject')] = ('ServiceLevel', ['Niveau de service applicable aux unités\n                        d’archives.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_service_level', 'object')] = ('ServiceLevel', ['Niveau de service applicable aux unités\n                        d’archives.'])
ETYPE_ATTR_DOC[('SEDAAcquisitionInformation', 'seda_acquisition_information_from', 'subject')] = ('AcquisitionInformation', ["Modalités d'entrée des archives."])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_acquisition_information_from', 'object')] = ('AcquisitionInformation', ["Modalités d'entrée des archives."])
ETYPE_ATTR_DOC[('SEDAAcquisitionInformation', 'seda_acquisition_information_to', 'subject')] = ('AcquisitionInformation', ["Modalités d'entrée des archives."])
ETYPE_ATTR_DOC[('Concept', 'seda_acquisition_information_to', 'object')] = ('AcquisitionInformation', ["Modalités d'entrée des archives."])
ETYPE_ATTR_DOC[('SEDALegalStatus', 'seda_legal_status_from', 'subject')] = ('LegalStatus', ['Statut des archives échangées.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_legal_status_from', 'object')] = ('LegalStatus', ['Statut des archives échangées.'])
ETYPE_ATTR_DOC[('SEDALegalStatus', 'seda_legal_status_to', 'subject')] = ('LegalStatus', ['Statut des archives échangées.'])
ETYPE_ATTR_DOC[('Concept', 'seda_legal_status_to', 'object')] = ('LegalStatus', ['Statut des archives échangées.'])
ETYPE_ATTR_DOC[('SEDAOriginatingAgencyIdentifier', 'seda_originating_agency_identifier', 'subject')] = ('OriginatingAgencyIdentifier', ['Identifiant du service producteur - information de gestion à\n                        ne pas confondre avec OriginatingAgency dans les métadonnées de\n                        description.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_originating_agency_identifier', 'object')] = ('OriginatingAgencyIdentifier', ['Identifiant du service producteur - information de gestion à\n                        ne pas confondre avec OriginatingAgency dans les métadonnées de\n                        description.'])
ETYPE_ATTR_DOC[('SEDASubmissionAgencyIdentifier', 'seda_submission_agency_identifier', 'subject')] = ('SubmissionAgencyIdentifier', ['Identifiant du service versant - information de gestion à ne\n                        pas confondre avec SubmissionAgency dans les métadonnées de\n                        description.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_submission_agency_identifier', 'object')] = ('SubmissionAgencyIdentifier', ['Identifiant du service versant - information de gestion à ne\n                        pas confondre avec SubmissionAgency dans les métadonnées de\n                        description.'])
ETYPE_ATTR_DOC[('SEDAStorageRule', 'seda_storage_rule', 'subject')] = ('StorageRule', ['Gestion de la durée d’utilité courante.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_storage_rule', 'object')] = ('StorageRule', ['Gestion de la durée d’utilité courante.'])
ETYPE_ATTR_DOC[('SEDAAppraisalRule', 'seda_appraisal_rule', 'subject')] = ('AppraisalRule', ['Gestion de la durée d’utilité administrative.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_appraisal_rule', 'object')] = ('AppraisalRule', ['Gestion de la durée d’utilité administrative.'])
ETYPE_ATTR_DOC[('SEDAAccessRule', 'seda_access_rule', 'subject')] = ('AccessRule', ['Gestion de la communicabilité.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_access_rule', 'object')] = ('AccessRule', ['Gestion de la communicabilité.'])
ETYPE_ATTR_DOC[('SEDADisseminationRule', 'seda_dissemination_rule', 'subject')] = ('DisseminationRule', ['Gestion de la diffusion.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_dissemination_rule', 'object')] = ('DisseminationRule', ['Gestion de la diffusion.'])
ETYPE_ATTR_DOC[('SEDAReuseRule', 'seda_reuse_rule', 'subject')] = ('ReuseRule', ['Gestion de la réutilisation.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_reuse_rule', 'object')] = ('ReuseRule', ['Gestion de la réutilisation.'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_classification_rule', 'subject')] = ('ClassificationRule', ['Gestion de la classification.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_classification_rule', 'object')] = ('ClassificationRule', ['Gestion de la classification.'])
ETYPE_ATTR_DOC[('SEDALogBook', 'seda_log_book', 'subject')] = ('LogBook', ['Gestion des traces.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_log_book', 'object')] = ('LogBook', ['Gestion des traces.'])
ETYPE_ATTR_DOC[('SEDANeedAuthorization', 'seda_need_authorization', 'subject')] = ('NeedAuthorization', ['Indique si une autorisation humaine est nécessaire pour vérifier ou valider les opérations de gestion des ArchiveUnit.'])
ETYPE_ATTR_DOC[('SEDAArchiveTransfer', 'seda_need_authorization', 'object')] = ('NeedAuthorization', ['Indique si une autorisation humaine est nécessaire pour vérifier ou valider les opérations de gestion des ArchiveUnit.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_need_authorization', 'object')] = ('NeedAuthorization', ['Indique si une autorisation humaine est nécessaire pour vérifier ou valider les opérations de gestion des ArchiveUnit.'])
ETYPE_ATTR_DOC[('SEDARelationship', 'seda_target', 'subject')] = ('target', ())
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_target', 'object')] = ('target', ())
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_target', 'object')] = ('target', ())
ETYPE_ATTR_DOC[('SEDARelationship', 'seda_type_relationship', 'subject')] = ('type', ())
ETYPE_ATTR_DOC[('Concept', 'seda_type_relationship', 'object')] = ('type', ())
ETYPE_ATTR_DOC[('SEDAAttachment', 'seda_attachment', 'subject')] = ('Attachment', ['Objet-données (contenu binaire ou fichier joint).'])
ETYPE_ATTR_DOC[('SEDAAltBinaryDataObjectAttachment', 'seda_attachment', 'object')] = ('Attachment', ['Objet-données (contenu binaire ou fichier joint).'])
ETYPE_ATTR_DOC[('SEDAUri', 'seda_uri', 'subject')] = ('Uri', ["L'URI spécifie où se trouve l'objet-données numérique. Peut correspondre à un chemin relatif."])
ETYPE_ATTR_DOC[('SEDAAltBinaryDataObjectAttachment', 'seda_uri', 'object')] = ('Uri', ["L'URI spécifie où se trouve l'objet-données numérique. Peut correspondre à 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', ['Forme littérale du nom du format.', 'Exemple : Microsoft Word Document.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_format_litteral', 'object')] = ('FormatLitteral', ['Forme littérale du nom du format.', 'Exemple : Microsoft Word Document.'])
ETYPE_ATTR_DOC[('SEDAMimeType', 'seda_mime_type_from', 'subject')] = ('MimeType', ['Type Mime associé, potentiellement stable mais pas assez précis.', 'Exemple : application/msword'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_mime_type_from', 'object')] = ('MimeType', ['Type Mime associé, potentiellement stable mais pas assez précis.', 'Exemple : application/msword'])
ETYPE_ATTR_DOC[('SEDAMimeType', 'seda_mime_type_to', 'subject')] = ('MimeType', ['Type Mime associé, potentiellement stable mais pas assez précis.', 'Exemple : application/msword'])
ETYPE_ATTR_DOC[('Concept', 'seda_mime_type_to', 'object')] = ('MimeType', ['Type Mime associé, potentiellement stable mais pas assez précis.', 'Exemple : application/msword'])
ETYPE_ATTR_DOC[('SEDAFormatId', 'seda_format_id_from', 'subject')] = ('FormatId', ['Type spécifique du format tel que défini dans FormatIdCodeList.', 'Exemple : (Pronom)fmt/40'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_format_id_from', 'object')] = ('FormatId', ['Type spécifique du format tel que défini dans FormatIdCodeList.', 'Exemple : (Pronom)fmt/40'])
ETYPE_ATTR_DOC[('SEDAFormatId', 'seda_format_id_to', 'subject')] = ('FormatId', ['Type spécifique du format tel que défini dans FormatIdCodeList.', 'Exemple : (Pronom)fmt/40'])
ETYPE_ATTR_DOC[('Concept', 'seda_format_id_to', 'object')] = ('FormatId', ['Type spécifique du format tel que défini dans FormatIdCodeList.', 'Exemple : (Pronom)fmt/40'])
ETYPE_ATTR_DOC[('SEDAEncoding', 'seda_encoding_from', 'subject')] = ('Encoding', ['Encodage du fichier tel que défini dans EncodingIdCodeList.', 'Exemple : Utf-8'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_encoding_from', 'object')] = ('Encoding', ['Encodage du fichier tel que défini dans EncodingIdCodeList.', 'Exemple : Utf-8'])
ETYPE_ATTR_DOC[('SEDAEncoding', 'seda_encoding_to', 'subject')] = ('Encoding', ['Encodage du fichier tel que défini dans EncodingIdCodeList.', 'Exemple : Utf-8'])
ETYPE_ATTR_DOC[('Concept', 'seda_encoding_to', 'object')] = ('Encoding', ['Encodage du fichier tel que défini dans EncodingIdCodeList.', 'Exemple : Utf-8'])
ETYPE_ATTR_DOC[('SEDACreatingApplicationName', 'seda_creating_application_name', 'subject')] = ('CreatingApplicationName', ["Nom de l'application utilisée pour créer le fichier."])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_creating_application_name', 'object')] = ('CreatingApplicationName', ["Nom de l'application utilisée pour créer le fichier."])
ETYPE_ATTR_DOC[('SEDACreatingApplicationVersion', 'seda_creating_application_version', 'subject')] = ('CreatingApplicationVersion', ["Version de l'application utilisée pour créer le fichier."])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_creating_application_version', 'object')] = ('CreatingApplicationVersion', ["Version de l'application utilisée pour créer le fichier."])
ETYPE_ATTR_DOC[('SEDADateCreatedByApplication', 'seda_date_created_by_application', 'subject')] = ('DateCreatedByApplication', ['Date de création du fichier.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_date_created_by_application', 'object')] = ('DateCreatedByApplication', ['Date de création du fichier.'])
ETYPE_ATTR_DOC[('SEDACreatingOs', 'seda_creating_os', 'subject')] = ('CreatingOs', ['Système d’exploitation utilisé pour créer le fichier.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_creating_os', 'object')] = ('CreatingOs', ['Système d’exploitation utilisé pour créer le fichier.'])
ETYPE_ATTR_DOC[('SEDACreatingOsVersion', 'seda_creating_os_version', 'subject')] = ('CreatingOsVersion', ["Version du système d'exploitation utilisé pour créer le fichier."])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_creating_os_version', 'object')] = ('CreatingOsVersion', ["Version du système d'exploitation utilisé pour créer le fichier."])
ETYPE_ATTR_DOC[('SEDALastModified', 'seda_last_modified', 'subject')] = ('LastModified', ['Date de la dernière modification du fichier.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_last_modified', 'object')] = ('LastModified', ['Date de la dernière modification du fichier.'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event', 'subject')] = ('Event', [])
ETYPE_ATTR_DOC[('SEDALogBook', 'seda_event', 'object')] = ('Event', [])
ETYPE_ATTR_DOC[('SEDAWidth', 'seda_width', 'subject')] = ('Width', ['Métadonnée de dimension physique : largeur.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_width', 'object')] = ('Width', ['Métadonnée de dimension physique : largeur.'])
ETYPE_ATTR_DOC[('SEDAHeight', 'seda_height', 'subject')] = ('Height', ['Métadonnée de dimension physique : hauteur.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_height', 'object')] = ('Height', ['Métadonnée de dimension physique : hauteur.'])
ETYPE_ATTR_DOC[('SEDADepth', 'seda_depth', 'subject')] = ('Depth', ['Métadonnée de dimension physique : profondeur.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_depth', 'object')] = ('Depth', ['Métadonnée de dimension physique : profondeur.'])
ETYPE_ATTR_DOC[('SEDAShape', 'seda_shape', 'subject')] = ('Shape', ['Métadonnée de dimension physique : forme.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_shape', 'object')] = ('Shape', ['Métadonnée de dimension physique : forme.'])
ETYPE_ATTR_DOC[('SEDADiameter', 'seda_diameter', 'subject')] = ('Diameter', ['Métadonnée de dimension physique : diamètre.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_diameter', 'object')] = ('Diameter', ['Métadonnée de dimension physique : diamètre.'])
ETYPE_ATTR_DOC[('SEDALength', 'seda_length', 'subject')] = ('Length', ['Métadonnée de dimension physique : longueur.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_length', 'object')] = ('Length', ['Métadonnée de dimension physique : longueur.'])
ETYPE_ATTR_DOC[('SEDAThickness', 'seda_thickness', 'subject')] = ('Thickness', ['Métadonnée de dimension physique : épaisseur.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_thickness', 'object')] = ('Thickness', ['Métadonnée de dimension physique : épaisseur.'])
ETYPE_ATTR_DOC[('SEDAWeight', 'seda_weight', 'subject')] = ('Weight', ['Métadonnée de dimension physique : poids.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_weight', 'object')] = ('Weight', ['Métadonnée de dimension physique : poids.'])
ETYPE_ATTR_DOC[('SEDANumberOfPage', 'seda_number_of_page', 'subject')] = ('NumberOfPage', ['Métadonnée de dimension physique : nombre de pages.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_number_of_page', 'object')] = ('NumberOfPage', ['Métadonnée de dimension physique : nombre de pages.'])
ETYPE_ATTR_DOC[('SEDAArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'subject')] = ('ArchiveUnitRefId', ["Permet de faire une référence à d'autres ArchiveUnit dans la même transaction."])
ETYPE_ATTR_DOC[('SEDAAltIsPartOfArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', ["Permet de faire une référence à d'autres ArchiveUnit dans la même transaction."])
ETYPE_ATTR_DOC[('SEDAAltReferencesArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', ["Permet de faire une référence à d'autres ArchiveUnit dans la même transaction."])
ETYPE_ATTR_DOC[('SEDAAltRequiresArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', ["Permet de faire une référence à d'autres ArchiveUnit dans la même transaction."])
ETYPE_ATTR_DOC[('SEDAAltArchiveUnitArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', ["Permet de faire une référence à d'autres ArchiveUnit dans la même transaction."])
ETYPE_ATTR_DOC[('SEDAAltIsVersionOfArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', ["Permet de faire une référence à d'autres ArchiveUnit dans la même transaction."])
ETYPE_ATTR_DOC[('SEDAAltReplacesArchiveUnitRefId', 'seda_archive_unit_ref_id_from', 'object')] = ('ArchiveUnitRefId', ["Permet de faire une référence à d'autres ArchiveUnit dans la même transaction."])
ETYPE_ATTR_DOC[('SEDAArchiveUnitRefId', 'seda_archive_unit_ref_id_to', 'subject')] = ('ArchiveUnitRefId', ["Permet de faire une référence à d'autres ArchiveUnit dans la même transaction."])
ETYPE_ATTR_DOC[('SEDAArchiveUnit', 'seda_archive_unit_ref_id_to', 'object')] = ('ArchiveUnitRefId', ["Permet de faire une référence à d'autres ArchiveUnit dans la même transaction."])
ETYPE_ATTR_DOC[('SEDAStorageRule', 'seda_final_action', 'subject')] = ('FinalAction', ['Action à mettre en œuvre au terme de la durée de gestion.'])
ETYPE_ATTR_DOC[('Concept', 'seda_final_action', 'object')] = ('FinalAction', ['Action à mettre en œuvre au terme de la durée de gestion.'])
ETYPE_ATTR_DOC[('SEDAAppraisalRule', 'seda_final_action', 'subject')] = ('FinalAction', ['Action à mettre en œuvre au terme de la durée de gestion.'])
ETYPE_ATTR_DOC[('Concept', 'seda_final_action', 'object')] = ('FinalAction', ['Action à mettre en œuvre au terme de la durée de gestion.'])
ETYPE_ATTR_DOC[('SEDAClassificationAudience', 'seda_classification_audience', 'subject')] = ('ClassificationAudience', ['Permet de gérer les questions de "diffusion restreinte", de "spécial France" et de "Confidentiel Industrie".'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_classification_audience', 'object')] = ('ClassificationAudience', ['Permet de gérer les questions de "diffusion restreinte", de "spécial France" et de "Confidentiel Industrie".'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_classification_level', 'subject')] = ('ClassificationLevel', ['Référence au niveau de classification.'])
ETYPE_ATTR_DOC[('Concept', 'seda_classification_level', 'object')] = ('ClassificationLevel', ['Référence au niveau de classification.'])
ETYPE_ATTR_DOC[('SEDAClassificationReassessingDate', 'seda_classification_reassessing_date', 'subject')] = ('ClassificationReassessingDate', ['Date de réévaluation de la classification.'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_classification_reassessing_date', 'object')] = ('ClassificationReassessingDate', ['Date de réévaluation de la classification.'])
ETYPE_ATTR_DOC[('SEDANeedReassessingAuthorization', 'seda_need_reassessing_authorization', 'subject')] = ('NeedReassessingAuthorization', ['Indique si une autorisation humaine est nécessaire pour réévaluer la classification.'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_need_reassessing_authorization', 'object')] = ('NeedReassessingAuthorization', ['Indique si une autorisation humaine est nécessaire pour réévaluer la classification.'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event', 'subject')] = ('Event', [])
ETYPE_ATTR_DOC[('SEDALogBook', 'seda_event', 'object')] = ('Event', [])
ETYPE_ATTR_DOC[('SEDAEventIdentifier', 'seda_event_identifier', 'subject')] = ('EventIdentifier', ["Identifiant de l'événement.", 'Références : premis.eventIdentifier'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_identifier', 'object')] = ('EventIdentifier', ["Identifiant de l'événement.", 'Références : premis.eventIdentifier'])
ETYPE_ATTR_DOC[('SEDAEventTypeCode', 'seda_event_type_code', 'subject')] = ('EventTypeCode', ["Code du type d'événement."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_type_code', 'object')] = ('EventTypeCode', ["Code du type d'événement."])
ETYPE_ATTR_DOC[('SEDAEventType', 'seda_event_type_from', 'subject')] = ('EventType', ["Type d'événement."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_type_from', 'object')] = ('EventType', ["Type d'événement."])
ETYPE_ATTR_DOC[('SEDAEventType', 'seda_event_type_to', 'subject')] = ('EventType', ["Type d'événement."])
ETYPE_ATTR_DOC[('Concept', 'seda_event_type_to', 'object')] = ('EventType', ["Type d'événement."])
ETYPE_ATTR_DOC[('SEDAEventDetail', 'seda_event_detail', 'subject')] = ('EventDetail', ["Détail sur l'événement."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_detail', 'object')] = ('EventDetail', ["Détail sur l'événement."])
ETYPE_ATTR_DOC[('SEDAOutcome', 'seda_outcome', 'subject')] = ('Outcome', ['Résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_outcome', 'object')] = ('Outcome', ['Résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAOutcomeDetail', 'seda_outcome_detail', 'subject')] = ('OutcomeDetail', ['Détail sur le résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_outcome_detail', 'object')] = ('OutcomeDetail', ['Détail sur le résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAOutcomeDetailMessage', 'seda_outcome_detail_message', 'subject')] = ('OutcomeDetailMessage', ['Message détaillé sur le résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_outcome_detail_message', 'object')] = ('OutcomeDetailMessage', ['Message détaillé sur le résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAEventDetailData', 'seda_event_detail_data', 'subject')] = ('EventDetailData', ["Message technique détaillant l'erreur."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_detail_data', 'object')] = ('EventDetailData', ["Message technique détaillant l'erreur."])
ETYPE_ATTR_DOC[('SEDAEventAbstract', 'seda_event_abstract', 'subject')] = ('EventAbstract', ["Permet d'ajouter de nouveau types d'événements dans l'ontologie."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_abstract', 'object')] = ('EventAbstract', ["Permet d'ajouter de nouveau types d'événements dans l'ontologie."])
ETYPE_ATTR_DOC[('SEDADataObjectReferenceId', 'seda_data_object_reference_id_from', 'subject')] = ('DataObjectReferenceId', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_data_object_reference_id_from', 'object')] = ('DataObjectReferenceId', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDADataObjectReferenceId', 'seda_data_object_reference_id_to', 'subject')] = ('DataObjectReferenceId', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_data_object_reference_id_to', 'object')] = ('DataObjectReferenceId', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_data_object_reference_id_to', 'object')] = ('DataObjectReferenceId', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDAArchiveUnit', 'seda_archive_unit', 'subject')] = ('ArchiveUnit', ['Correspond à la notion de composant en ISAD(G). ArchiveUnit\n                        permet à la fois de gérer la hiérarchie intellectuelle, tout en contenant\n                        les métadonnées de description et de gestion propres à chaque niveau de\n                        description archivistique.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_archive_unit', 'object')] = ('ArchiveUnit', ['Correspond à la notion de composant en ISAD(G). ArchiveUnit\n                        permet à la fois de gérer la hiérarchie intellectuelle, tout en contenant\n                        les métadonnées de description et de gestion propres à chaque niveau de\n                        description archivistique.'])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_data_object_reference', 'object')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAEventTypeCode', 'seda_event_type_code', 'subject')] = ('EventTypeCode', ["Code du type d'événement."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_type_code', 'object')] = ('EventTypeCode', ["Code du type d'événement."])
ETYPE_ATTR_DOC[('SEDAEventDetail', 'seda_event_detail', 'subject')] = ('EventDetail', ["Détail sur l'événement."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_detail', 'object')] = ('EventDetail', ["Détail sur l'événement."])
ETYPE_ATTR_DOC[('SEDAOutcome', 'seda_outcome', 'subject')] = ('Outcome', ['Résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_outcome', 'object')] = ('Outcome', ['Résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAOutcomeDetail', 'seda_outcome_detail', 'subject')] = ('OutcomeDetail', ['Détail sur le résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_outcome_detail', 'object')] = ('OutcomeDetail', ['Détail sur le résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAOutcomeDetailMessage', 'seda_outcome_detail_message', 'subject')] = ('OutcomeDetailMessage', ['Message détaillé sur le résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_outcome_detail_message', 'object')] = ('OutcomeDetailMessage', ['Message détaillé sur le résultat du traitement.'])
ETYPE_ATTR_DOC[('SEDAEventDetailData', 'seda_event_detail_data', 'subject')] = ('EventDetailData', ["Message technique détaillant l'erreur."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_detail_data', 'object')] = ('EventDetailData', ["Message technique détaillant l'erreur."])
ETYPE_ATTR_DOC[('SEDAEventAbstract', 'seda_event_abstract', 'subject')] = ('EventAbstract', ["Permet d'ajouter de nouveau types d'événements dans l'ontologie."])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event_abstract', 'object')] = ('EventAbstract', ["Permet d'ajouter de nouveau types d'événements dans l'ontologie."])
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', ['Gestion de la durée d’utilité courante.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_storage_rule', 'object')] = ('StorageRule', ['Gestion de la durée d’utilité courante.'])
ETYPE_ATTR_DOC[('SEDAAppraisalRule', 'seda_appraisal_rule', 'subject')] = ('AppraisalRule', ['Gestion de la durée d’utilité administrative.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_appraisal_rule', 'object')] = ('AppraisalRule', ['Gestion de la durée d’utilité administrative.'])
ETYPE_ATTR_DOC[('SEDAAccessRule', 'seda_access_rule', 'subject')] = ('AccessRule', ['Gestion de la communicabilité.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_access_rule', 'object')] = ('AccessRule', ['Gestion de la communicabilité.'])
ETYPE_ATTR_DOC[('SEDADisseminationRule', 'seda_dissemination_rule', 'subject')] = ('DisseminationRule', ['Gestion de la diffusion.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_dissemination_rule', 'object')] = ('DisseminationRule', ['Gestion de la diffusion.'])
ETYPE_ATTR_DOC[('SEDAReuseRule', 'seda_reuse_rule', 'subject')] = ('ReuseRule', ['Gestion de la réutilisation.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_reuse_rule', 'object')] = ('ReuseRule', ['Gestion de la réutilisation.'])
ETYPE_ATTR_DOC[('SEDAClassificationRule', 'seda_classification_rule', 'subject')] = ('ClassificationRule', ['Gestion de la classification.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_classification_rule', 'object')] = ('ClassificationRule', ['Gestion de la classification.'])
ETYPE_ATTR_DOC[('SEDALogBook', 'seda_log_book', 'subject')] = ('LogBook', ['Gestion des traces.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_log_book', 'object')] = ('LogBook', ['Gestion des traces.'])
ETYPE_ATTR_DOC[('SEDADescriptionLevel', 'seda_description_level_from', 'subject')] = ('DescriptionLevel', ['Niveau de description au sens de la norme ISAD (G). Indique si l’ArchiveUnit correspond à un fonds, \n                        à un sous-fonds, à une classe, à une série organique, à une sous-série organique, à un dossier, à un sous-dossier ou à une pièce.', 'Référence : seda.DescriptionLevel'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_description_level_from', 'object')] = ('DescriptionLevel', ['Niveau de description au sens de la norme ISAD (G). Indique si l’ArchiveUnit correspond à un fonds, \n                        à un sous-fonds, à une classe, à une série organique, à une sous-série organique, à un dossier, à un sous-dossier ou à une pièce.', 'Référence : seda.DescriptionLevel'])
ETYPE_ATTR_DOC[('SEDADescriptionLevel', 'seda_description_level_to', 'subject')] = ('DescriptionLevel', ['Niveau de description au sens de la norme ISAD (G). Indique si l’ArchiveUnit correspond à un fonds, \n                        à un sous-fonds, à une classe, à une série organique, à une sous-série organique, à un dossier, à un sous-dossier ou à une pièce.', 'Référence : seda.DescriptionLevel'])
ETYPE_ATTR_DOC[('Concept', 'seda_description_level_to', 'object')] = ('DescriptionLevel', ['Niveau de description au sens de la norme ISAD (G). Indique si l’ArchiveUnit correspond à un fonds, \n                        à un sous-fonds, à une classe, à une série organique, à une sous-série organique, à un dossier, à un sous-dossier ou à une pièce.', 'Référence : seda.DescriptionLevel'])
ETYPE_ATTR_DOC[('SEDATitle', 'seda_title', 'subject')] = ('Title', ["Intitulé de l'ArchiveUnit.", 'Références : DC.Title ead.unittitle'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_title', 'object')] = ('Title', ["Intitulé de l'ArchiveUnit.", 'Références : DC.Title ead.unittitle'])
ETYPE_ATTR_DOC[('SEDAFilePlanPosition', 'seda_file_plan_position', 'subject')] = ('FilePlanPosition', ['Position de l’ArchiveUnit dans le plan de classement du service producteur.', 'Références : seda.FilePlanPosition'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_file_plan_position', 'object')] = ('FilePlanPosition', ['Position de l’ArchiveUnit dans le plan de classement du service producteur.', 'Références : seda.FilePlanPosition'])
ETYPE_ATTR_DOC[('SEDASystemId', 'seda_system_id', 'subject')] = ('SystemId', ['Identifiant attribué aux objets. Il est attribué par le SAE et correspond à un identifiant interne.', 'Références : ARMS'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_system_id', 'object')] = ('SystemId', ['Identifiant attribué aux objets. Il est attribué par le SAE et correspond à un identifiant interne.', 'Références : ARMS'])
ETYPE_ATTR_DOC[('SEDAOriginatingSystemId', 'seda_originating_system_id', 'subject')] = ('OriginatingSystemId', ['Identifiant système attribué à l’ArchiveUnit par l’application du service producteur.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_originating_system_id', 'object')] = ('OriginatingSystemId', ['Identifiant système attribué à l’ArchiveUnit par l’application du service producteur.'])
ETYPE_ATTR_DOC[('SEDAArchivalAgencyArchiveUnitIdentifier', 'seda_archival_agency_archive_unit_identifier', 'subject')] = ('ArchivalAgencyArchiveUnitIdentifier', ["Identifiant métier attribué à l'ArchiveUnit par le service d'archives. Peut être comparé à une cote."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_archival_agency_archive_unit_identifier', 'object')] = ('ArchivalAgencyArchiveUnitIdentifier', ["Identifiant métier attribué à l'ArchiveUnit par le service d'archives. Peut être comparé à une cote."])
ETYPE_ATTR_DOC[('SEDAOriginatingAgencyArchiveUnitIdentifier', 'seda_originating_agency_archive_unit_identifier', 'subject')] = ('OriginatingAgencyArchiveUnitIdentifier', ['Identifiant métier attribué à l’ArchiveUnit par le service producteur.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_originating_agency_archive_unit_identifier', 'object')] = ('OriginatingAgencyArchiveUnitIdentifier', ['Identifiant métier attribué à l’ArchiveUnit par le service producteur.'])
ETYPE_ATTR_DOC[('SEDATransferringAgencyArchiveUnitIdentifier', 'seda_transferring_agency_archive_unit_identifier', 'subject')] = ('TransferringAgencyArchiveUnitIdentifier', ["Identifiant attribué à l'ArchiveUnit par le service versant."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_transferring_agency_archive_unit_identifier', 'object')] = ('TransferringAgencyArchiveUnitIdentifier', ["Identifiant attribué à l'ArchiveUnit par le service versant."])
ETYPE_ATTR_DOC[('SEDADescription', 'seda_description', 'subject')] = ('Description', ['Description détaillée de l’ArchiveUnit. Correspond à la présentation du contenu au sens de la norme ISAD(G).', 'Références : DC:Documentation'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_description', 'object')] = ('Description', ['Description détaillée de l’ArchiveUnit. Correspond à la présentation du contenu au sens de la norme ISAD(G).', 'Références : DC:Documentation'])
ETYPE_ATTR_DOC[('SEDAType', 'seda_type_from', 'subject')] = ('Type', ['Type d’information au sens de l’OAIS (information de représentation, information de pérennisation, etc.).', 'Références : seda.DocumentType'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_type_from', 'object')] = ('Type', ['Type d’information au sens de l’OAIS (information de représentation, information de pérennisation, etc.).', 'Références : seda.DocumentType'])
ETYPE_ATTR_DOC[('SEDAType', 'seda_type_to', 'subject')] = ('Type', ['Type d’information au sens de l’OAIS (information de représentation, information de pérennisation, etc.).', 'Références : seda.DocumentType'])
ETYPE_ATTR_DOC[('Concept', 'seda_type_to', 'object')] = ('Type', ['Type d’information au sens de l’OAIS (information de représentation, information de pérennisation, etc.).', 'Références : seda.DocumentType'])
ETYPE_ATTR_DOC[('SEDADocumentType', 'seda_document_type', 'subject')] = ('DocumentType', ['Type de document au sens diplomatique du terme (ex. compte-rendu de réunion, note, correspondance, etc.). Ne pas confondre avec Type.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_document_type', 'object')] = ('DocumentType', ['Type de document au sens diplomatique du terme (ex. compte-rendu de réunion, note, correspondance, etc.). Ne pas confondre avec Type.'])
ETYPE_ATTR_DOC[('SEDALanguage', 'seda_language_from', 'subject')] = ('Language', ['Langue du contenu des objets-données.', 'Références : seda.Language'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_language_from', 'object')] = ('Language', ['Langue du contenu des objets-données.', 'Références : seda.Language'])
ETYPE_ATTR_DOC[('SEDALanguage', 'seda_language_to', 'subject')] = ('Language', ['Langue du contenu des objets-données.', 'Références : seda.Language'])
ETYPE_ATTR_DOC[('Concept', 'seda_language_to', 'object')] = ('Language', ['Langue du contenu des objets-données.', 'Références : seda.Language'])
ETYPE_ATTR_DOC[('SEDADescriptionLanguage', 'seda_description_language_from', 'subject')] = ('DescriptionLanguage', ['Langue utilisée pour les informations de représentation et de pérennisation.', 'Références : seda.DescriptionLanguage'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_description_language_from', 'object')] = ('DescriptionLanguage', ['Langue utilisée pour les informations de représentation et de pérennisation.', 'Références : seda.DescriptionLanguage'])
ETYPE_ATTR_DOC[('SEDADescriptionLanguage', 'seda_description_language_to', 'subject')] = ('DescriptionLanguage', ['Langue utilisée pour les informations de représentation et de pérennisation.', 'Références : seda.DescriptionLanguage'])
ETYPE_ATTR_DOC[('Concept', 'seda_description_language_to', 'object')] = ('DescriptionLanguage', ['Langue utilisée pour les informations de représentation et de pérennisation.', 'Références : seda.DescriptionLanguage'])
ETYPE_ATTR_DOC[('SEDAStatus', 'seda_status', 'subject')] = ('Status', ["Etat de l'objet-données (par rapport avec son cycle de vie). Permet par exemple d'indiquer si la signature du fichier a été vérifiée avant le transfert aux archives.", 'Références : seda.Status'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_status', 'object')] = ('Status', ["Etat de l'objet-données (par rapport avec son cycle de vie). Permet par exemple d'indiquer si la signature du fichier a été vérifiée avant le transfert aux archives.", 'Références : seda.Status'])
ETYPE_ATTR_DOC[('SEDAVersion', 'seda_version', 'subject')] = ('Version', ["Permet d'indiquer quelle est la version du document."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_version', 'object')] = ('Version', ["Permet d'indiquer quelle est la version du document."])
ETYPE_ATTR_DOC[('SEDATag', 'seda_tag', 'subject')] = ('Tag', ["Mots-clés ou liste de mots-clés génériques. En ce qui concerne l'indexation, on pourra utiliser Tag ou Keyword en fonction de ce que l'on souhaite décrire."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_tag', 'object')] = ('Tag', ["Mots-clés ou liste de mots-clés génériques. En ce qui concerne l'indexation, on pourra utiliser Tag ou Keyword en fonction de ce que l'on souhaite décrire."])
ETYPE_ATTR_DOC[('SEDAKeyword', 'seda_keyword', 'subject')] = ('Keyword', ["Mots-clef avec contexte inspiré 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écrire.", 'Références : seda.Keyword'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_keyword', 'object')] = ('Keyword', ["Mots-clef avec contexte inspiré 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écrire.", 'Références : seda.Keyword'])
ETYPE_ATTR_DOC[('SEDAOriginatingAgency', 'seda_originating_agency_from', 'subject')] = ('OriginatingAgency', ['Service producteur. "Personne physique ou morale, publique ou privée, qui a produit, reçu et conservé des archives  dans l\'exercice de son activité", Dictionnaire de terminologie archivistique, direction des archives de France, 2002.', 'Références : seda.OriginatingAgency'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_originating_agency_from', 'object')] = ('OriginatingAgency', ['Service producteur. "Personne physique ou morale, publique ou privée, qui a produit, reçu et conservé des archives  dans l\'exercice de son activité", Dictionnaire de terminologie archivistique, direction des archives de France, 2002.', 'Références : seda.OriginatingAgency'])
ETYPE_ATTR_DOC[('SEDAOriginatingAgency', 'seda_originating_agency_to', 'subject')] = ('OriginatingAgency', ['Service producteur. "Personne physique ou morale, publique ou privée, qui a produit, reçu et conservé des archives  dans l\'exercice de son activité", Dictionnaire de terminologie archivistique, direction des archives de France, 2002.', 'Références : seda.OriginatingAgency'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_originating_agency_to', 'object')] = ('OriginatingAgency', ['Service producteur. "Personne physique ou morale, publique ou privée, qui a produit, reçu et conservé des archives  dans l\'exercice de son activité", Dictionnaire de terminologie archivistique, direction des archives de France, 2002.', 'Références : seda.OriginatingAgency'])
ETYPE_ATTR_DOC[('SEDASubmissionAgency', 'seda_submission_agency_from', 'subject')] = ('SubmissionAgency', ['Service versant responsable du transfert des données.', 'Références : seda.SubmissionAgency'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_submission_agency_from', 'object')] = ('SubmissionAgency', ['Service versant responsable du transfert des données.', 'Références : seda.SubmissionAgency'])
ETYPE_ATTR_DOC[('SEDASubmissionAgency', 'seda_submission_agency_to', 'subject')] = ('SubmissionAgency', ['Service versant responsable du transfert des données.', 'Références : seda.SubmissionAgency'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_submission_agency_to', 'object')] = ('SubmissionAgency', ['Service versant responsable du transfert des données.', 'Références : seda.SubmissionAgency'])
ETYPE_ATTR_DOC[('SEDAAgentAbstract', 'seda_agent_abstract', 'subject')] = ('AgentAbstract', ["Permet d'ajouter de nouveau types d'agents dans l'ontologie."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_agent_abstract', 'object')] = ('AgentAbstract', ["Permet d'ajouter de nouveau types d'agents dans l'ontologie."])
ETYPE_ATTR_DOC[('SEDAAuthorizedAgent', 'seda_authorized_agent_from', 'subject')] = ('AuthorizedAgent', ['Titulaire des droits de propriété intellectuelle.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_authorized_agent_from', 'object')] = ('AuthorizedAgent', ['Titulaire des droits de propriété intellectuelle.'])
ETYPE_ATTR_DOC[('SEDAAuthorizedAgent', 'seda_authorized_agent_to', 'subject')] = ('AuthorizedAgent', ['Titulaire des droits de propriété intellectuelle.'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_authorized_agent_to', 'object')] = ('AuthorizedAgent', ['Titulaire des droits de propriété intellectuelle.'])
ETYPE_ATTR_DOC[('SEDAWriter', 'seda_writer_from', 'subject')] = ('Writer', ['Rédacteur Rédacteur de l’ArchiveUnit.', 'Références : interpares.Writer'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_writer_from', 'object')] = ('Writer', ['Rédacteur Rédacteur de l’ArchiveUnit.', 'Références : interpares.Writer'])
ETYPE_ATTR_DOC[('SEDAWriter', 'seda_writer_to', 'subject')] = ('Writer', ['Rédacteur Rédacteur de l’ArchiveUnit.', 'Références : interpares.Writer'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_writer_to', 'object')] = ('Writer', ['Rédacteur Rédacteur de l’ArchiveUnit.', 'Références : interpares.Writer'])
ETYPE_ATTR_DOC[('SEDAAddressee', 'seda_addressee_from', 'subject')] = ('Addressee', ['Destinataire pour action. Utilisé pour indiquer le nom du destinatire par exemple dans un courrier électronique.', 'Références : ARMS.Addressee, Interpares.Addressee'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_addressee_from', 'object')] = ('Addressee', ['Destinataire pour action. Utilisé pour indiquer le nom du destinatire par exemple dans un courrier électronique.', 'Références : ARMS.Addressee, Interpares.Addressee'])
ETYPE_ATTR_DOC[('SEDAAddressee', 'seda_addressee_to', 'subject')] = ('Addressee', ['Destinataire pour action. Utilisé pour indiquer le nom du destinatire par exemple dans un courrier électronique.', 'Références : ARMS.Addressee, Interpares.Addressee'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_addressee_to', 'object')] = ('Addressee', ['Destinataire pour action. Utilisé pour indiquer le nom du destinatire par exemple dans un courrier électronique.', 'Références : ARMS.Addressee, Interpares.Addressee'])
ETYPE_ATTR_DOC[('SEDARecipient', 'seda_recipient_from', 'subject')] = ('Recipient', ['Destinataire pour information. Utilisé pour indiquer le nom du destinatire en copie, pour information, par exemple dans un courrier électronique.', 'Références : Interpares.Recipient'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_recipient_from', 'object')] = ('Recipient', ['Destinataire pour information. Utilisé pour indiquer le nom du destinatire en copie, pour information, par exemple dans un courrier électronique.', 'Références : Interpares.Recipient'])
ETYPE_ATTR_DOC[('SEDARecipient', 'seda_recipient_to', 'subject')] = ('Recipient', ['Destinataire pour information. Utilisé pour indiquer le nom du destinatire en copie, pour information, par exemple dans un courrier électronique.', 'Références : Interpares.Recipient'])
ETYPE_ATTR_DOC[('AuthorityRecord', 'seda_recipient_to', 'object')] = ('Recipient', ['Destinataire pour information. Utilisé pour indiquer le nom du destinatire en copie, pour information, par exemple dans un courrier électronique.', 'Références : Interpares.Recipient'])
ETYPE_ATTR_DOC[('SEDATransmitter', 'seda_transmitter', 'subject')] = ('Transmitter', ['Emetteur du message.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_transmitter', 'object')] = ('Transmitter', ['Emetteur du message.'])
ETYPE_ATTR_DOC[('SEDASender', 'seda_sender', 'subject')] = ('Sender', ['Expéditeur du message.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_sender', 'object')] = ('Sender', ['Expéditeur du message.'])
ETYPE_ATTR_DOC[('SEDASource', 'seda_source', 'subject')] = ('Source', ['En cas de substitution numérique, permet de faire référence au papier.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_source', 'object')] = ('Source', ['En cas de substitution numérique, permet de faire référence au papier.'])
ETYPE_ATTR_DOC[('SEDACreatedDate', 'seda_created_date', 'subject')] = ('CreatedDate', ['Date de création.', 'Références : ARKMS.DateCreated'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_created_date', 'object')] = ('CreatedDate', ['Date de création.', 'Références : ARKMS.DateCreated'])
ETYPE_ATTR_DOC[('SEDATransactedDate', 'seda_transacted_date', 'subject')] = ('TransactedDate', ['Date de la transaction.', 'Références : ARKMS.DateTransacted'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_transacted_date', 'object')] = ('TransactedDate', ['Date de la transaction.', 'Références : ARKMS.DateTransacted'])
ETYPE_ATTR_DOC[('SEDAAcquiredDate', 'seda_acquired_date', 'subject')] = ('AcquiredDate', ['Date de numérisation.', 'Références : ARKMS.DateAcquired'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_acquired_date', 'object')] = ('AcquiredDate', ['Date de numérisation.', 'Références : ARKMS.DateAcquired'])
ETYPE_ATTR_DOC[('SEDASentDate', 'seda_sent_date', 'subject')] = ('SentDate', ["Date d'envoi."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_sent_date', 'object')] = ('SentDate', ["Date d'envoi."])
ETYPE_ATTR_DOC[('SEDAReceivedDate', 'seda_received_date', 'subject')] = ('ReceivedDate', ['Date de réception.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_received_date', 'object')] = ('ReceivedDate', ['Date de réception.'])
ETYPE_ATTR_DOC[('SEDARegisteredDate', 'seda_registered_date', 'subject')] = ('RegisteredDate', ["Date d'enregistrement.", 'Références : ARMS.DateDeclared'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_registered_date', 'object')] = ('RegisteredDate', ["Date d'enregistrement.", 'Références : ARMS.DateDeclared'])
ETYPE_ATTR_DOC[('SEDAStartDate', 'seda_start_date', 'subject')] = ('StartDate', ["Date d'ouverture / date de début.", 'Références : AGKRMS.StartDate'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_start_date', 'object')] = ('StartDate', ["Date d'ouverture / date de début.", 'Références : AGKRMS.StartDate'])
ETYPE_ATTR_DOC[('SEDAEndDate', 'seda_end_date', 'subject')] = ('EndDate', ['Date de fermeture / Date de fin.', 'Références : AGKRMS.EndDate'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_end_date', 'object')] = ('EndDate', ['Date de fermeture / Date de fin.', 'Références : AGKRMS.EndDate'])
ETYPE_ATTR_DOC[('SEDAEvent', 'seda_event', 'subject')] = ('Event', [])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_event', 'object')] = ('Event', [])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference_id', 'subject')] = ('DataObjectReferenceId', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_data_object_reference_id', 'object')] = ('DataObjectReferenceId', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_data_object_reference_id', 'object')] = ('DataObjectReferenceId', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDASeqStorageRuleRule', 'seda_rule', 'subject')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('SEDAStartDate', 'seda_start_date', 'subject')] = ('StartDate', ["Date de départ de calcul de la règle d'utilité courante."])
ETYPE_ATTR_DOC[('SEDASeqAppraisalRuleRule', 'seda_start_date', 'object')] = ('StartDate', ["Date de départ de calcul de la règle d'utilité courante."])
ETYPE_ATTR_DOC[('SEDASeqClassificationRuleRule', 'seda_start_date', 'object')] = ('StartDate', ["Date de départ de calcul de la règle d'utilité courante."])
ETYPE_ATTR_DOC[('SEDASeqAccessRuleRule', 'seda_start_date', 'object')] = ('StartDate', ["Date de départ de calcul de la règle d'utilité courante."])
ETYPE_ATTR_DOC[('SEDASeqDisseminationRuleRule', 'seda_start_date', 'object')] = ('StartDate', ["Date de départ de calcul de la règle d'utilité courante."])
ETYPE_ATTR_DOC[('SEDASeqReuseRuleRule', 'seda_start_date', 'object')] = ('StartDate', ["Date de départ de calcul de la règle d'utilité courante."])
ETYPE_ATTR_DOC[('SEDASeqStorageRuleRule', 'seda_start_date', 'object')] = ('StartDate', ["Date de départ de calcul de la règle d'utilité courante."])
ETYPE_ATTR_DOC[('SEDAPreventInheritance', 'seda_prevent_inheritance', 'subject')] = ('PreventInheritance', ['Indique si les règles de gestion héritées des ArchiveUnit parents doivent être ignorées pour l’ArchiveUnit concerné.'])
ETYPE_ATTR_DOC[('SEDAAltAccessRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', ['Indique si les règles de gestion héritées des ArchiveUnit parents doivent être ignorées pour l’ArchiveUnit concerné.'])
ETYPE_ATTR_DOC[('SEDAAltAppraisalRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', ['Indique si les règles de gestion héritées des ArchiveUnit parents doivent être ignorées pour l’ArchiveUnit concerné.'])
ETYPE_ATTR_DOC[('SEDAAltStorageRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', ['Indique si les règles de gestion héritées des ArchiveUnit parents doivent être ignorées pour l’ArchiveUnit concerné.'])
ETYPE_ATTR_DOC[('SEDAAltDisseminationRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', ['Indique si les règles de gestion héritées des ArchiveUnit parents doivent être ignorées pour l’ArchiveUnit concerné.'])
ETYPE_ATTR_DOC[('SEDAAltClassificationRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', ['Indique si les règles de gestion héritées des ArchiveUnit parents doivent être ignorées pour l’ArchiveUnit concerné.'])
ETYPE_ATTR_DOC[('SEDAAltReuseRulePreventInheritance', 'seda_prevent_inheritance', 'object')] = ('PreventInheritance', ['Indique si les règles de gestion héritées des ArchiveUnit parents doivent être ignorées pour l’ArchiveUnit concerné.'])
ETYPE_ATTR_DOC[('SEDARefNonRuleId', 'seda_ref_non_rule_id_from', 'subject')] = ('RefNonRuleId', ["L'identifiant de la règle spécifiée pourra être retirée de l'héritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltAccessRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', ["L'identifiant de la règle spécifiée pourra être retirée de l'héritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltAppraisalRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', ["L'identifiant de la règle spécifiée pourra être retirée de l'héritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltStorageRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', ["L'identifiant de la règle spécifiée pourra être retirée de l'héritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltDisseminationRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', ["L'identifiant de la règle spécifiée pourra être retirée de l'héritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltClassificationRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', ["L'identifiant de la règle spécifiée pourra être retirée de l'héritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDAAltReuseRulePreventInheritance', 'seda_ref_non_rule_id_from', 'object')] = ('RefNonRuleId', ["L'identifiant de la règle spécifiée pourra être retirée de l'héritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDARefNonRuleId', 'seda_ref_non_rule_id_to', 'subject')] = ('RefNonRuleId', ["L'identifiant de la règle spécifiée pourra être retirée de l'héritage dans ce noeud."])
ETYPE_ATTR_DOC[('Concept', 'seda_ref_non_rule_id_to', 'object')] = ('RefNonRuleId', ["L'identifiant de la règle spécifiée pourra être retirée de l'héritage dans ce noeud."])
ETYPE_ATTR_DOC[('SEDASeqAppraisalRuleRule', 'seda_rule', 'subject')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('SEDASeqAccessRuleRule', 'seda_rule', 'subject')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('SEDASeqDisseminationRuleRule', 'seda_rule', 'subject')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('SEDASeqReuseRuleRule', 'seda_rule', 'subject')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('SEDASeqClassificationRuleRule', 'seda_rule', 'subject')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('Concept', 'seda_rule', 'object')] = ('Rule', ["Référence à la règle de durée d'utilité courante."])
ETYPE_ATTR_DOC[('SEDACustodialHistoryItem', 'seda_custodial_history_item', 'subject')] = ('CustodialHistoryItem', ["Description d'une période ou d'un événement précis dans l'historique.", 'Références : seda.CustodialHistoryItem'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_custodial_history_item', 'object')] = ('CustodialHistoryItem', ["Description d'une période ou d'un événement précis dans l'historique.", 'Références : seda.CustodialHistoryItem'])
ETYPE_ATTR_DOC[('SEDACustodialHistoryFile', 'seda_custodial_history_file', 'subject')] = ('CustodialHistoryFile', ['Référence à un fichier de journalisation externe.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_custodial_history_file', 'object')] = ('CustodialHistoryFile', ['Référence à un fichier de journalisation externe.'])
ETYPE_ATTR_DOC[('SEDAKeywordReference', 'seda_keyword_reference_from', 'subject')] = ('KeywordReference', ["Identifiant du mot clé dans un référentiel donné. Par exemple, pour un lieu, il pourrait s'agir de son code officiel géographique selon l'INSEE."])
ETYPE_ATTR_DOC[('SEDAKeyword', 'seda_keyword_reference_from', 'object')] = ('KeywordReference', ["Identifiant du mot clé dans un référentiel donné. Par exemple, pour un lieu, il pourrait s'agir de son code officiel géographique selon l'INSEE."])
ETYPE_ATTR_DOC[('SEDAKeywordReference', 'seda_keyword_reference_to', 'subject')] = ('KeywordReference', ["Identifiant du mot clé dans un référentiel donné. Par exemple, pour un lieu, il pourrait s'agir de son code officiel géographique selon l'INSEE."])
ETYPE_ATTR_DOC[('Concept', 'seda_keyword_reference_to', 'object')] = ('KeywordReference', ["Identifiant du mot clé dans un référentiel donné. Par exemple, pour un lieu, il pourrait s'agir de son code officiel géographique selon l'INSEE."])
ETYPE_ATTR_DOC[('SEDAKeywordType', 'seda_keyword_type_from', 'subject')] = ('KeywordType', ['Type de mot clé.'])
ETYPE_ATTR_DOC[('SEDAKeyword', 'seda_keyword_type_from', 'object')] = ('KeywordType', ['Type de mot clé.'])
ETYPE_ATTR_DOC[('SEDAKeywordType', 'seda_keyword_type_to', 'subject')] = ('KeywordType', ['Type de mot clé.'])
ETYPE_ATTR_DOC[('Concept', 'seda_keyword_type_to', 'object')] = ('KeywordType', ['Type de mot clé.'])
ETYPE_ATTR_DOC[('SEDASpatial', 'seda_spatial', 'subject')] = ('Spatial', ['Couverture spatiale ou couverture géographique.', 'Références: AGKRMS.spatialCoverage'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_spatial', 'object')] = ('Spatial', ['Couverture spatiale ou couverture géographique.', 'Références: AGKRMS.spatialCoverage'])
ETYPE_ATTR_DOC[('SEDATemporal', 'seda_temporal', 'subject')] = ('Temporal', ['Couverture temporelle.', 'Références: AGKRMS.temporalCoverage'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_temporal', 'object')] = ('Temporal', ['Couverture temporelle.', 'Références: AGKRMS.temporalCoverage'])
ETYPE_ATTR_DOC[('SEDAJuridictional', 'seda_juridictional', 'subject')] = ('Juridictional', ['Juridiction administrative ou ressort administratif.', 'Références: AGKRMS.juridictionalCoverage'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_juridictional', 'object')] = ('Juridictional', ['Juridiction administrative ou ressort administratif.', 'Références: AGKRMS.juridictionalCoverage'])
ETYPE_ATTR_DOC[('SEDAIdentifier', 'seda_identifier', 'subject')] = ('Identifier', ["Identifiant de la personne (par exemple, le numéro matricule) ou de l'entité."])
ETYPE_ATTR_DOC[('SEDAAgentAbstract', 'seda_identifier', 'object')] = ('Identifier', ["Identifiant de la personne (par exemple, le numéro matricule) ou de l'entité."])
ETYPE_ATTR_DOC[('SEDAFunction', 'seda_function', 'subject')] = ('Function', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Fonction."])
ETYPE_ATTR_DOC[('SEDAAgentAbstract', 'seda_function', 'object')] = ('Function', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Fonction."])
ETYPE_ATTR_DOC[('SEDAActivity', 'seda_activity', 'subject')] = ('Activity', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Activité."])
ETYPE_ATTR_DOC[('SEDAAgentAbstract', 'seda_activity', 'object')] = ('Activity', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Activité."])
ETYPE_ATTR_DOC[('SEDAPosition', 'seda_position', 'subject')] = ('Position', ['Intitulé du poste de travail occupé par la personne.'])
ETYPE_ATTR_DOC[('SEDAAgentAbstract', 'seda_position', 'object')] = ('Position', ['Intitulé du poste de travail occupé par la personne.'])
ETYPE_ATTR_DOC[('SEDARole', 'seda_role', 'subject')] = ('Role', ['Droits avec lesquels un utilisateur a réalisé une opération, notamment dans une application.', 'Références : moreq.role'])
ETYPE_ATTR_DOC[('SEDAAgentAbstract', 'seda_role', 'object')] = ('Role', ['Droits avec lesquels un utilisateur a réalisé une opération, notamment dans une application.', 'Références : moreq.role'])
ETYPE_ATTR_DOC[('SEDAMandate', 'seda_mandate', 'subject')] = ('Mandate', ['Définit la propriété intellectuelle et artistique.'])
ETYPE_ATTR_DOC[('SEDAAgentAbstract', 'seda_mandate', 'object')] = ('Mandate', ['Définit la propriété intellectuelle et artistique.'])
ETYPE_ATTR_DOC[('SEDAIdentifier', 'seda_identifier', 'subject')] = ('Identifier', ["Identifiant de la personne (par exemple, le numéro matricule) ou de l'entité."])
ETYPE_ATTR_DOC[('SEDATransmitter', 'seda_identifier', 'object')] = ('Identifier', ["Identifiant de la personne (par exemple, le numéro matricule) ou de l'entité."])
ETYPE_ATTR_DOC[('SEDAFunction', 'seda_function', 'subject')] = ('Function', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Fonction."])
ETYPE_ATTR_DOC[('SEDATransmitter', 'seda_function', 'object')] = ('Function', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Fonction."])
ETYPE_ATTR_DOC[('SEDAActivity', 'seda_activity', 'subject')] = ('Activity', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Activité."])
ETYPE_ATTR_DOC[('SEDATransmitter', 'seda_activity', 'object')] = ('Activity', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Activité."])
ETYPE_ATTR_DOC[('SEDAPosition', 'seda_position', 'subject')] = ('Position', ['Intitulé du poste de travail occupé par la personne.'])
ETYPE_ATTR_DOC[('SEDATransmitter', 'seda_position', 'object')] = ('Position', ['Intitulé du poste de travail occupé par la personne.'])
ETYPE_ATTR_DOC[('SEDARole', 'seda_role', 'subject')] = ('Role', ['Droits avec lesquels un utilisateur a réalisé une opération, notamment dans une application.', 'Références : moreq.role'])
ETYPE_ATTR_DOC[('SEDATransmitter', 'seda_role', 'object')] = ('Role', ['Droits avec lesquels un utilisateur a réalisé une opération, notamment dans une application.', 'Références : moreq.role'])
ETYPE_ATTR_DOC[('SEDAMandate', 'seda_mandate', 'subject')] = ('Mandate', ['Définit la propriété intellectuelle et artistique.'])
ETYPE_ATTR_DOC[('SEDATransmitter', 'seda_mandate', 'object')] = ('Mandate', ['Définit la propriété intellectuelle et artistique.'])
ETYPE_ATTR_DOC[('SEDAIdentifier', 'seda_identifier', 'subject')] = ('Identifier', ["Identifiant de la personne (par exemple, le numéro matricule) ou de l'entité."])
ETYPE_ATTR_DOC[('SEDASender', 'seda_identifier', 'object')] = ('Identifier', ["Identifiant de la personne (par exemple, le numéro matricule) ou de l'entité."])
ETYPE_ATTR_DOC[('SEDAFunction', 'seda_function', 'subject')] = ('Function', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Fonction."])
ETYPE_ATTR_DOC[('SEDASender', 'seda_function', 'object')] = ('Function', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Fonction."])
ETYPE_ATTR_DOC[('SEDAActivity', 'seda_activity', 'subject')] = ('Activity', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Activité."])
ETYPE_ATTR_DOC[('SEDASender', 'seda_activity', 'object')] = ('Activity', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Activité."])
ETYPE_ATTR_DOC[('SEDAPosition', 'seda_position', 'subject')] = ('Position', ['Intitulé du poste de travail occupé par la personne.'])
ETYPE_ATTR_DOC[('SEDASender', 'seda_position', 'object')] = ('Position', ['Intitulé du poste de travail occupé par la personne.'])
ETYPE_ATTR_DOC[('SEDARole', 'seda_role', 'subject')] = ('Role', ['Droits avec lesquels un utilisateur a réalisé une opération, notamment dans une application.', 'Références : moreq.role'])
ETYPE_ATTR_DOC[('SEDASender', 'seda_role', 'object')] = ('Role', ['Droits avec lesquels un utilisateur a réalisé une opération, notamment dans une application.', 'Références : moreq.role'])
ETYPE_ATTR_DOC[('SEDAMandate', 'seda_mandate', 'subject')] = ('Mandate', ['Définit la propriété intellectuelle et artistique.'])
ETYPE_ATTR_DOC[('SEDASender', 'seda_mandate', 'object')] = ('Mandate', ['Définit la propriété intellectuelle et artistique.'])
ETYPE_ATTR_DOC[('SEDAIsVersionOf', 'seda_is_version_of', 'subject')] = ('IsVersionOf', ["Est une version de. Edition, adaptation, traduction. Cette relation permet d'indiquer les modifications dans le contenu.", 'Références : DC.Relation.isVersionOf'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_is_version_of', 'object')] = ('IsVersionOf', ["Est une version de. Edition, adaptation, traduction. Cette relation permet d'indiquer les modifications dans le contenu.", 'Références : DC.Relation.isVersionOf'])
ETYPE_ATTR_DOC[('SEDAReplaces', 'seda_replaces', 'subject')] = ('Replaces', ["Remplace. Cette relation permet d'indiquer les objets remplacés par le niveau courant de description.", 'DC.Relation.replaces'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_replaces', 'object')] = ('Replaces', ["Remplace. Cette relation permet d'indiquer les objets remplacés par le niveau courant de description.", 'DC.Relation.replaces'])
ETYPE_ATTR_DOC[('SEDARequires', 'seda_requires', 'subject')] = ('Requires', ["Requiert. Cette relation permet d'indiquer les objets nécessaire à la compréhension du niveau courant de description.", 'Références : DC.Relation.requires'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_requires', 'object')] = ('Requires', ["Requiert. Cette relation permet d'indiquer les objets nécessaire à la compréhension du niveau courant de description.", 'Références : DC.Relation.requires'])
ETYPE_ATTR_DOC[('SEDAIsPartOf', 'seda_is_part_of', 'subject')] = ('IsPartOf', ["Est une partie de. Cette relation permet d'indique qu'un objet est une partie d'un autre.", 'Références : DC.Relation.isPartOf'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_is_part_of', 'object')] = ('IsPartOf', ["Est une partie de. Cette relation permet d'indique qu'un objet est une partie d'un autre.", 'Références : DC.Relation.isPartOf'])
ETYPE_ATTR_DOC[('SEDAReferences', 'seda_references', 'subject')] = ('References', ["Référence. Cette relation permet d'indiquer qu'un objet en référence un autre.", 'DC.Relation.references'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_references', 'object')] = ('References', ["Référence. Cette relation permet d'indiquer qu'un objet en référence un autre.", 'DC.Relation.references'])
ETYPE_ATTR_DOC[('SEDAGpsVersionID', 'seda_gps_version_id', 'subject')] = ('GpsVersionID', ['Identifiant de la version du GPS.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_version_id', 'object')] = ('GpsVersionID', ['Identifiant de la version du GPS.'])
ETYPE_ATTR_DOC[('SEDAGpsAltitude', 'seda_gps_altitude', 'subject')] = ('GpsAltitude', ["Indique l'altitude basée sur la référence dans GPSAltitudeRef. L'altitude est exprimée en mètres."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_altitude', 'object')] = ('GpsAltitude', ["Indique l'altitude basée sur la référence dans GPSAltitudeRef. L'altitude est exprimée en mètres."])
ETYPE_ATTR_DOC[('SEDAGpsAltitudeRef', 'seda_gps_altitude_ref', 'subject')] = ('GpsAltitudeRef', ["Indique l'altitude utilisée comme altitude de référence.", "Si l'altitude est au dessus du niveau de la mer, la valeur 0 est normalement donnée.", "Si l'altitude est au-dessous du niveau de la mer, la veleur 1 est normalement donnée."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_altitude_ref', 'object')] = ('GpsAltitudeRef', ["Indique l'altitude utilisée comme altitude de référence.", "Si l'altitude est au dessus du niveau de la mer, la valeur 0 est normalement donnée.", "Si l'altitude est au-dessous du niveau de la mer, la veleur 1 est normalement donnée."])
ETYPE_ATTR_DOC[('SEDAGpsLatitude', 'seda_gps_latitude', 'subject')] = ('GpsLatitude', ['La latitude peut être exprimée de deux manières différentes : 1)degrés, décimaux ou 2)degrés, minutes et secondes.', '1)Si la latitude est exprimée en degrés, décimaux, le format type est dd, dd. Par ex: "45.3130339".', '2)Si la latitude est exprimée en degrés, minutes et secondes, le format type est dd, mm, ss. Par ex: "45 18 46.922".'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_latitude', 'object')] = ('GpsLatitude', ['La latitude peut être exprimée de deux manières différentes : 1)degrés, décimaux ou 2)degrés, minutes et secondes.', '1)Si la latitude est exprimée en degrés, décimaux, le format type est dd, dd. Par ex: "45.3130339".', '2)Si la latitude est exprimée en degrés, minutes et secondes, le format type est dd, mm, ss. Par ex: "45 18 46.922".'])
ETYPE_ATTR_DOC[('SEDAGpsLatitudeRef', 'seda_gps_latitude_ref', 'subject')] = ('GpsLatitudeRef', ["Indique si la latitude est nord ou sud. La valeur 'N' indique la latitude nord, et 'S' indique la latitude sud."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_latitude_ref', 'object')] = ('GpsLatitudeRef', ["Indique si la latitude est nord ou sud. La valeur 'N' indique la latitude nord, et 'S' indique la latitude sud."])
ETYPE_ATTR_DOC[('SEDAGpsLongitude', 'seda_gps_longitude', 'subject')] = ('GpsLongitude', ['La longitude peut être exprimée de deux manières différentes : 1)degrés, décimaux ou 2)degrés, minutes et secondes.', '1)Si la longitude est exprimée en degrés, décimaux, le format type est dd, dd. Par ex: "5.392285833333334".', '2)Si la longitude est exprimée en degrés, minutes et secondes, le format type est dd, mm, ss. Par ex: "5 23 32.229".'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_longitude', 'object')] = ('GpsLongitude', ['La longitude peut être exprimée de deux manières différentes : 1)degrés, décimaux ou 2)degrés, minutes et secondes.', '1)Si la longitude est exprimée en degrés, décimaux, le format type est dd, dd. Par ex: "5.392285833333334".', '2)Si la longitude est exprimée en degrés, minutes et secondes, le format type est dd, mm, ss. Par ex: "5 23 32.229".'])
ETYPE_ATTR_DOC[('SEDAGpsLongitudeRef', 'seda_gps_longitude_ref', 'subject')] = ('GpsLongitudeRef', ["Indique si la longitude est est ou ouest. La valeur 'E' indique la longitude est, et 'W' indique la longitude Ouest."])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_longitude_ref', 'object')] = ('GpsLongitudeRef', ["Indique si la longitude est est ou ouest. La valeur 'E' indique la longitude est, et 'W' indique la longitude Ouest."])
ETYPE_ATTR_DOC[('SEDAGpsDateStamp', 'seda_gps_date_stamp', 'subject')] = ('GpsDateStamp', ['Heure et Date de la position GPS.'])
ETYPE_ATTR_DOC[('SEDASeqAltArchiveUnitArchiveUnitRefIdManagement', 'seda_gps_date_stamp', 'object')] = ('GpsDateStamp', ['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', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDABinaryDataObject', 'seda_data_object_reference_id', 'object')] = ('DataObjectReferenceId', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDAPhysicalDataObject', 'seda_data_object_reference_id', 'object')] = ('DataObjectReferenceId', ['Permet de faire référence à un objet-donnée binaire ou physique déjà présent dans les métadonnées du bordereau.'])
ETYPE_ATTR_DOC[('SEDACorpname', 'seda_corpname', 'subject')] = ('Corpname', ["Nom d'une entité."])
ETYPE_ATTR_DOC[('SEDAAltSenderCorpname', 'seda_corpname', 'object')] = ('Corpname', ["Nom d'une entité."])
ETYPE_ATTR_DOC[('SEDAAltAgentAbstractCorpname', 'seda_corpname', 'object')] = ('Corpname', ["Nom d'une entité."])
ETYPE_ATTR_DOC[('SEDAAltTransmitterCorpname', 'seda_corpname', 'object')] = ('Corpname', ["Nom d'une entité."])
ETYPE_ATTR_DOC[('SEDAFirstName', 'seda_first_name', 'subject')] = ('FirstName', ["Prénom d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltTransmitterCorpnameFirstName', 'seda_first_name', 'object')] = ('FirstName', ["Prénom d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltSenderCorpnameFirstName', 'seda_first_name', 'object')] = ('FirstName', ["Prénom d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltAgentAbstractCorpnameFirstName', 'seda_first_name', 'object')] = ('FirstName', ["Prénom d'une personne."])
ETYPE_ATTR_DOC[('SEDABirthName', 'seda_birth_name', 'subject')] = ('BirthName', ["Nom de naissance d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltTransmitterCorpnameFirstName', 'seda_birth_name', 'object')] = ('BirthName', ["Nom de naissance d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltSenderCorpnameFirstName', 'seda_birth_name', 'object')] = ('BirthName', ["Nom de naissance d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltAgentAbstractCorpnameFirstName', 'seda_birth_name', 'object')] = ('BirthName', ["Nom de naissance d'une personne."])
ETYPE_ATTR_DOC[('SEDAFullName', 'seda_full_name', 'subject')] = ('FullName', ["Nom complet d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltTransmitterCorpnameFirstName', 'seda_full_name', 'object')] = ('FullName', ["Nom complet d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltSenderCorpnameFirstName', 'seda_full_name', 'object')] = ('FullName', ["Nom complet d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltAgentAbstractCorpnameFirstName', 'seda_full_name', 'object')] = ('FullName', ["Nom complet d'une personne."])
ETYPE_ATTR_DOC[('SEDAGivenName', 'seda_given_name', 'subject')] = ('GivenName', ["Nom d'usage d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltTransmitterCorpnameFirstName', 'seda_given_name', 'object')] = ('GivenName', ["Nom d'usage d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltSenderCorpnameFirstName', 'seda_given_name', 'object')] = ('GivenName', ["Nom d'usage d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltAgentAbstractCorpnameFirstName', 'seda_given_name', 'object')] = ('GivenName', ["Nom d'usage d'une personne."])
ETYPE_ATTR_DOC[('SEDAGender', 'seda_gender', 'subject')] = ('Gender', ['Sexe de la personne.'])
ETYPE_ATTR_DOC[('SEDASeqAltAgentAbstractCorpnameFirstName', 'seda_gender', 'object')] = ('Gender', ['Sexe de la personne.'])
ETYPE_ATTR_DOC[('SEDABirthDate', 'seda_birth_date', 'subject')] = ('BirthDate', ['Date de naissance de la personne.'])
ETYPE_ATTR_DOC[('SEDASeqAltTransmitterCorpnameFirstName', 'seda_birth_date', 'object')] = ('BirthDate', ['Date de naissance de la personne.'])
ETYPE_ATTR_DOC[('SEDASeqAltSenderCorpnameFirstName', 'seda_birth_date', 'object')] = ('BirthDate', ['Date de naissance de la personne.'])
ETYPE_ATTR_DOC[('SEDASeqAltAgentAbstractCorpnameFirstName', 'seda_birth_date', 'object')] = ('BirthDate', ['Date de naissance de la personne.'])
ETYPE_ATTR_DOC[('SEDABirthPlace', 'seda_birth_place', 'subject')] = ('BirthPlace', ['Lieu de naissance de la personne.'])
ETYPE_ATTR_DOC[('SEDASeqAltAgentAbstractCorpnameFirstName', 'seda_birth_place', 'object')] = ('BirthPlace', ['Lieu de naissance de la personne.'])
ETYPE_ATTR_DOC[('SEDADeathDate', 'seda_death_date', 'subject')] = ('DeathDate', ["Date de décès d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltTransmitterCorpnameFirstName', 'seda_death_date', 'object')] = ('DeathDate', ["Date de décès d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltSenderCorpnameFirstName', 'seda_death_date', 'object')] = ('DeathDate', ["Date de décès d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltAgentAbstractCorpnameFirstName', 'seda_death_date', 'object')] = ('DeathDate', ["Date de décès d'une personne."])
ETYPE_ATTR_DOC[('SEDADeathPlace', 'seda_death_place', 'subject')] = ('DeathPlace', ["Lieu de décès d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltAgentAbstractCorpnameFirstName', 'seda_death_place', 'object')] = ('DeathPlace', ["Lieu de décès d'une personne."])
ETYPE_ATTR_DOC[('SEDANationality', 'seda_nationality', 'subject')] = ('Nationality', ["Nationalité d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltAgentAbstractCorpnameFirstName', 'seda_nationality', 'object')] = ('Nationality', ["Nationalité d'une personne."])
ETYPE_ATTR_DOC[('SEDAGender', 'seda_gender', 'subject')] = ('Gender', ['Sexe de la personne.'])
ETYPE_ATTR_DOC[('SEDASeqAltTransmitterCorpnameFirstName', 'seda_gender', 'object')] = ('Gender', ['Sexe de la personne.'])
ETYPE_ATTR_DOC[('SEDABirthPlace', 'seda_birth_place', 'subject')] = ('BirthPlace', ['Lieu de naissance de la personne.'])
ETYPE_ATTR_DOC[('SEDASeqAltTransmitterCorpnameFirstName', 'seda_birth_place', 'object')] = ('BirthPlace', ['Lieu de naissance de la personne.'])
ETYPE_ATTR_DOC[('SEDADeathPlace', 'seda_death_place', 'subject')] = ('DeathPlace', ["Lieu de décès d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltTransmitterCorpnameFirstName', 'seda_death_place', 'object')] = ('DeathPlace', ["Lieu de décès d'une personne."])
ETYPE_ATTR_DOC[('SEDANationality', 'seda_nationality', 'subject')] = ('Nationality', ["Nationalité d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltTransmitterCorpnameFirstName', 'seda_nationality', 'object')] = ('Nationality', ["Nationalité d'une personne."])
ETYPE_ATTR_DOC[('SEDAGender', 'seda_gender', 'subject')] = ('Gender', ['Sexe de la personne.'])
ETYPE_ATTR_DOC[('SEDASeqAltSenderCorpnameFirstName', 'seda_gender', 'object')] = ('Gender', ['Sexe de la personne.'])
ETYPE_ATTR_DOC[('SEDABirthPlace', 'seda_birth_place', 'subject')] = ('BirthPlace', ['Lieu de naissance de la personne.'])
ETYPE_ATTR_DOC[('SEDASeqAltSenderCorpnameFirstName', 'seda_birth_place', 'object')] = ('BirthPlace', ['Lieu de naissance de la personne.'])
ETYPE_ATTR_DOC[('SEDADeathPlace', 'seda_death_place', 'subject')] = ('DeathPlace', ["Lieu de décès d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltSenderCorpnameFirstName', 'seda_death_place', 'object')] = ('DeathPlace', ["Lieu de décès d'une personne."])
ETYPE_ATTR_DOC[('SEDANationality', 'seda_nationality', 'subject')] = ('Nationality', ["Nationalité d'une personne."])
ETYPE_ATTR_DOC[('SEDASeqAltSenderCorpnameFirstName', 'seda_nationality', 'object')] = ('Nationality', ["Nationalité d'une personne."])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAAltIsVersionOfArchiveUnitRefId', 'seda_data_object_reference', 'object')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAExternalReference', 'seda_external_reference', 'subject')] = ('ExternalReference', ['Référence externe.'])
ETYPE_ATTR_DOC[('SEDAAltIsVersionOfArchiveUnitRefId', 'seda_external_reference', 'object')] = ('ExternalReference', ['Référence externe.'])
ETYPE_ATTR_DOC[('SEDARepositoryArchiveUnitPID', 'seda_repository_archive_unit_pid', 'subject')] = ('RepositoryArchiveUnitPID', ["Référence à un ArchiveUnit déjà conservé dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltIsPartOfArchiveUnitRefId', 'seda_repository_archive_unit_pid', 'object')] = ('RepositoryArchiveUnitPID', ["Référence à un ArchiveUnit déjà conservé dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltReferencesArchiveUnitRefId', 'seda_repository_archive_unit_pid', 'object')] = ('RepositoryArchiveUnitPID', ["Référence à un ArchiveUnit déjà conservé dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltRequiresArchiveUnitRefId', 'seda_repository_archive_unit_pid', 'object')] = ('RepositoryArchiveUnitPID', ["Référence à un ArchiveUnit déjà conservé dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltIsVersionOfArchiveUnitRefId', 'seda_repository_archive_unit_pid', 'object')] = ('RepositoryArchiveUnitPID', ["Référence à un ArchiveUnit déjà conservé dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltReplacesArchiveUnitRefId', 'seda_repository_archive_unit_pid', 'object')] = ('RepositoryArchiveUnitPID', ["Référence à un ArchiveUnit déjà conservé dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDARepositoryObjectPID', 'seda_repository_object_pid', 'subject')] = ('RepositoryObjectPID', ["Référence à un un objet-données ou à un groupe d'objets-données déjà conservé(s) dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltIsPartOfArchiveUnitRefId', 'seda_repository_object_pid', 'object')] = ('RepositoryObjectPID', ["Référence à un un objet-données ou à un groupe d'objets-données déjà conservé(s) dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltReferencesArchiveUnitRefId', 'seda_repository_object_pid', 'object')] = ('RepositoryObjectPID', ["Référence à un un objet-données ou à un groupe d'objets-données déjà conservé(s) dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltRequiresArchiveUnitRefId', 'seda_repository_object_pid', 'object')] = ('RepositoryObjectPID', ["Référence à un un objet-données ou à un groupe d'objets-données déjà conservé(s) dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltIsVersionOfArchiveUnitRefId', 'seda_repository_object_pid', 'object')] = ('RepositoryObjectPID', ["Référence à un un objet-données ou à un groupe d'objets-données déjà conservé(s) dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDAAltReplacesArchiveUnitRefId', 'seda_repository_object_pid', 'object')] = ('RepositoryObjectPID', ["Référence à un un objet-données ou à un groupe d'objets-données déjà conservé(s) dans un système d'archivage."])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAAltReplacesArchiveUnitRefId', 'seda_data_object_reference', 'object')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAExternalReference', 'seda_external_reference', 'subject')] = ('ExternalReference', ['Référence externe.'])
ETYPE_ATTR_DOC[('SEDAAltReplacesArchiveUnitRefId', 'seda_external_reference', 'object')] = ('ExternalReference', ['Référence externe.'])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAAltRequiresArchiveUnitRefId', 'seda_data_object_reference', 'object')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAExternalReference', 'seda_external_reference', 'subject')] = ('ExternalReference', ['Référence externe.'])
ETYPE_ATTR_DOC[('SEDAAltRequiresArchiveUnitRefId', 'seda_external_reference', 'object')] = ('ExternalReference', ['Référence externe.'])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAAltIsPartOfArchiveUnitRefId', 'seda_data_object_reference', 'object')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAExternalReference', 'seda_external_reference', 'subject')] = ('ExternalReference', ['Référence externe.'])
ETYPE_ATTR_DOC[('SEDAAltIsPartOfArchiveUnitRefId', 'seda_external_reference', 'object')] = ('ExternalReference', ['Référence externe.'])
ETYPE_ATTR_DOC[('SEDADataObjectReference', 'seda_data_object_reference', 'subject')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAAltReferencesArchiveUnitRefId', 'seda_data_object_reference', 'object')] = ('DataObjectReference', ["Référence à un objet-données ou à un groupe d'objets-données interne(s)."])
ETYPE_ATTR_DOC[('SEDAExternalReference', 'seda_external_reference', 'subject')] = ('ExternalReference', ['Référence externe.'])
ETYPE_ATTR_DOC[('SEDAAltReferencesArchiveUnitRefId', 'seda_external_reference', 'object')] = ('ExternalReference', ['Référence externe.'])
ETYPE_ATTR_DOC[('SEDAAddress', 'seda_address', 'subject')] = ('Address', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Adresse.", 'Références : ead.address'])
ETYPE_ATTR_DOC[('SEDADeathPlace', 'seda_address', 'object')] = ('Address', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Adresse.", 'Références : ead.address'])
ETYPE_ATTR_DOC[('SEDABirthPlace', 'seda_address', 'object')] = ('Address', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Adresse.", 'Références : ead.address'])
ETYPE_ATTR_DOC[('SEDACity', 'seda_city', 'subject')] = ('City', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Ville."])
ETYPE_ATTR_DOC[('SEDADeathPlace', 'seda_city', 'object')] = ('City', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Ville."])
ETYPE_ATTR_DOC[('SEDABirthPlace', 'seda_city', 'object')] = ('City', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Ville."])
ETYPE_ATTR_DOC[('SEDACountry', 'seda_country', 'subject')] = ('Country', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Pays."])
ETYPE_ATTR_DOC[('SEDADeathPlace', 'seda_country', 'object')] = ('Country', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Pays."])
ETYPE_ATTR_DOC[('SEDABirthPlace', 'seda_country', 'object')] = ('Country', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Pays."])
ETYPE_ATTR_DOC[('SEDAGeogname', 'seda_geogname', 'subject')] = ('Geogname', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Nom géographique.", 'Références : ead.geogname'])
ETYPE_ATTR_DOC[('SEDADeathPlace', 'seda_geogname', 'object')] = ('Geogname', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Nom géographique.", 'Références : ead.geogname'])
ETYPE_ATTR_DOC[('SEDABirthPlace', 'seda_geogname', 'object')] = ('Geogname', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Nom géographique.", 'Références : ead.geogname'])
ETYPE_ATTR_DOC[('SEDAPostalCode', 'seda_postal_code', 'subject')] = ('PostalCode', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Code postal."])
ETYPE_ATTR_DOC[('SEDADeathPlace', 'seda_postal_code', 'object')] = ('PostalCode', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Code postal."])
ETYPE_ATTR_DOC[('SEDABirthPlace', 'seda_postal_code', 'object')] = ('PostalCode', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Code postal."])
ETYPE_ATTR_DOC[('SEDARegion', 'seda_region', 'subject')] = ('Region', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Région."])
ETYPE_ATTR_DOC[('SEDADeathPlace', 'seda_region', 'object')] = ('Region', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Région."])
ETYPE_ATTR_DOC[('SEDABirthPlace', 'seda_region', 'object')] = ('Region', ["En plus des balises Tag et Keyword, il est possible d'indexer les objets avec des éléments pré-définis : Région."])
