/**
 * Copyright (c) 2020 CEA LIST, Committer Name, and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 * 
 * SPDX-License-Identifier: EPL-2.0
 * 
 * Contributors:
 * CEA LIST - Initial API and implementation
 * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
 * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
 * 
 */
package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;

/**
 * <!-- begin-user-doc -->
 * The <b>Package</b> for the model.
 * It contains accessors for the meta objects to represent
 * <ul>
 *   <li>each class,</li>
 *   <li>each feature of each class,</li>
 *   <li>each operation of each class,</li>
 *   <li>each enum,</li>
 *   <li>and each data type</li>
 * </ul>
 * <!-- end-user-doc -->
 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRFactory
 * @model kind="package"
 * @generated
 */
public interface Pdp4engCommonGDPRPackage extends EPackage {
	/**
	 * The package name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNAME = "pdp4engCommonGDPR";

	/**
	 * The package namespace URI.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNS_URI = "http://org.eclipse.papyrus.pdp4eng.common.profile";

	/**
	 * The package namespace name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNS_PREFIX = "pdp4engCommonGDPR";

	/**
	 * The singleton instance of the package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	Pdp4engCommonGDPRPackage eINSTANCE = org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl.init();

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl <em>Process</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getProcess()
	 * @generated
	 */
	int PROCESS = 0;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS__BASE_NAMED_ELEMENT = 0;

	/**
	 * The feature id for the '<em><b>Personaldata</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS__PERSONALDATA = 1;

	/**
	 * The feature id for the '<em><b>Contributed To</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS__CONTRIBUTED_TO = 2;

	/**
	 * The feature id for the '<em><b>Perform AContract</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS__PERFORM_ACONTRACT = 3;

	/**
	 * The feature id for the '<em><b>Data</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS__DATA = 4;

	/**
	 * The feature id for the '<em><b>Needed For Public Interest</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS__NEEDED_FOR_PUBLIC_INTEREST = 5;

	/**
	 * The feature id for the '<em><b>Needed For Legimate Interest</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS__NEEDED_FOR_LEGIMATE_INTEREST = 6;

	/**
	 * The feature id for the '<em><b>Needed For Legal Obligation</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS__NEEDED_FOR_LEGAL_OBLIGATION = 7;

	/**
	 * The feature id for the '<em><b>Needed For Vital Interest</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS__NEEDED_FOR_VITAL_INTEREST = 8;

	/**
	 * The number of structural features of the '<em>Process</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS_FEATURE_COUNT = 9;

	/**
	 * The number of operations of the '<em>Process</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataImpl <em>Data</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getData()
	 * @generated
	 */
	int DATA = 2;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA__BASE_NAMED_ELEMENT = 0;

	/**
	 * The number of structural features of the '<em>Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_FEATURE_COUNT = 1;

	/**
	 * The number of operations of the '<em>Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl <em>Personal Data</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPersonalData()
	 * @generated
	 */
	int PERSONAL_DATA = 1;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PERSONAL_DATA__BASE_NAMED_ELEMENT = DATA__BASE_NAMED_ELEMENT;

	/**
	 * The feature id for the '<em><b>Related To</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PERSONAL_DATA__RELATED_TO = DATA_FEATURE_COUNT + 0;

	/**
	 * The feature id for the '<em><b>Responsible</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PERSONAL_DATA__RESPONSIBLE = DATA_FEATURE_COUNT + 1;

	/**
	 * The feature id for the '<em><b>Processed By</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PERSONAL_DATA__PROCESSED_BY = DATA_FEATURE_COUNT + 2;

	/**
	 * The number of structural features of the '<em>Personal Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PERSONAL_DATA_FEATURE_COUNT = DATA_FEATURE_COUNT + 3;

	/**
	 * The number of operations of the '<em>Personal Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PERSONAL_DATA_OPERATION_COUNT = DATA_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl <em>Data Subject</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getDataSubject()
	 * @generated
	 */
	int DATA_SUBJECT = 3;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_SUBJECT__BASE_NAMED_ELEMENT = 0;

	/**
	 * The feature id for the '<em><b>Given Consent</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_SUBJECT__GIVEN_CONSENT = 1;

	/**
	 * The feature id for the '<em><b>Contract</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_SUBJECT__CONTRACT = 2;

	/**
	 * The feature id for the '<em><b>Personal Data</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_SUBJECT__PERSONAL_DATA = 3;

	/**
	 * The number of structural features of the '<em>Data Subject</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_SUBJECT_FEATURE_COUNT = 4;

	/**
	 * The number of operations of the '<em>Data Subject</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_SUBJECT_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl <em>Consent</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getConsent()
	 * @generated
	 */
	int CONSENT = 4;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONSENT__BASE_NAMED_ELEMENT = 0;

	/**
	 * The feature id for the '<em><b>Purpose</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONSENT__PURPOSE = 1;

	/**
	 * The feature id for the '<em><b>Datasubject</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONSENT__DATASUBJECT = 2;

	/**
	 * The number of structural features of the '<em>Consent</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONSENT_FEATURE_COUNT = 3;

	/**
	 * The number of operations of the '<em>Consent</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONSENT_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl <em>Purpose</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPurpose()
	 * @generated
	 */
	int PURPOSE = 5;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PURPOSE__BASE_NAMED_ELEMENT = 0;

	/**
	 * The feature id for the '<em><b>Processes</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PURPOSE__PROCESSES = 1;

	/**
	 * The feature id for the '<em><b>Consent</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PURPOSE__CONSENT = 2;

	/**
	 * The number of structural features of the '<em>Purpose</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PURPOSE_FEATURE_COUNT = 3;

	/**
	 * The number of operations of the '<em>Purpose</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PURPOSE_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl <em>Contract</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getContract()
	 * @generated
	 */
	int CONTRACT = 6;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONTRACT__BASE_NAMED_ELEMENT = 0;

	/**
	 * The feature id for the '<em><b>Process</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONTRACT__PROCESS = 1;

	/**
	 * The feature id for the '<em><b>Datasubject</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONTRACT__DATASUBJECT = 2;

	/**
	 * The number of structural features of the '<em>Contract</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONTRACT_FEATURE_COUNT = 3;

	/**
	 * The number of operations of the '<em>Contract</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONTRACT_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl <em>Controller</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getController()
	 * @generated
	 */
	int CONTROLLER = 7;

	/**
	 * The feature id for the '<em><b>Processor</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONTROLLER__PROCESSOR = 0;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONTROLLER__BASE_NAMED_ELEMENT = 1;

	/**
	 * The feature id for the '<em><b>Personal Data</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONTROLLER__PERSONAL_DATA = 2;

	/**
	 * The number of structural features of the '<em>Controller</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONTROLLER_FEATURE_COUNT = 3;

	/**
	 * The number of operations of the '<em>Controller</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CONTROLLER_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl <em>Processor</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getProcessor()
	 * @generated
	 */
	int PROCESSOR = 8;

	/**
	 * The feature id for the '<em><b>Process</b></em>' reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESSOR__PROCESS = 0;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESSOR__BASE_NAMED_ELEMENT = 1;

	/**
	 * The number of structural features of the '<em>Processor</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESSOR_FEATURE_COUNT = 2;

	/**
	 * The number of operations of the '<em>Processor</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESSOR_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PublicInterestImpl <em>Public Interest</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PublicInterestImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPublicInterest()
	 * @generated
	 */
	int PUBLIC_INTEREST = 9;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PUBLIC_INTEREST__BASE_NAMED_ELEMENT = 0;

	/**
	 * The number of structural features of the '<em>Public Interest</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PUBLIC_INTEREST_FEATURE_COUNT = 1;

	/**
	 * The number of operations of the '<em>Public Interest</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PUBLIC_INTEREST_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegitimateInterestImpl <em>Legitimate Interest</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegitimateInterestImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getLegitimateInterest()
	 * @generated
	 */
	int LEGITIMATE_INTEREST = 10;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT = 0;

	/**
	 * The number of structural features of the '<em>Legitimate Interest</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LEGITIMATE_INTEREST_FEATURE_COUNT = 1;

	/**
	 * The number of operations of the '<em>Legitimate Interest</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LEGITIMATE_INTEREST_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegalObligationImpl <em>Legal Obligation</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegalObligationImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getLegalObligation()
	 * @generated
	 */
	int LEGAL_OBLIGATION = 11;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LEGAL_OBLIGATION__BASE_NAMED_ELEMENT = 0;

	/**
	 * The number of structural features of the '<em>Legal Obligation</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LEGAL_OBLIGATION_FEATURE_COUNT = 1;

	/**
	 * The number of operations of the '<em>Legal Obligation</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LEGAL_OBLIGATION_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.VitalInterestImpl <em>Vital Interest</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.VitalInterestImpl
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getVitalInterest()
	 * @generated
	 */
	int VITAL_INTEREST = 12;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int VITAL_INTEREST__BASE_NAMED_ELEMENT = 0;

	/**
	 * The number of structural features of the '<em>Vital Interest</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int VITAL_INTEREST_FEATURE_COUNT = 1;

	/**
	 * The number of operations of the '<em>Vital Interest</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int VITAL_INTEREST_OPERATION_COUNT = 0;


	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process <em>Process</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Process</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process
	 * @generated
	 */
	EClass getProcess();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getBase_NamedElement()
	 * @see #getProcess()
	 * @generated
	 */
	EReference getProcess_Base_NamedElement();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPersonaldata <em>Personaldata</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Personaldata</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPersonaldata()
	 * @see #getProcess()
	 * @generated
	 */
	EReference getProcess_Personaldata();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getContributedTo <em>Contributed To</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Contributed To</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getContributedTo()
	 * @see #getProcess()
	 * @generated
	 */
	EReference getProcess_ContributedTo();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPerformAContract <em>Perform AContract</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Perform AContract</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPerformAContract()
	 * @see #getProcess()
	 * @generated
	 */
	EReference getProcess_PerformAContract();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getData <em>Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Data</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getData()
	 * @see #getProcess()
	 * @generated
	 */
	EReference getProcess_Data();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForPublicInterest <em>Needed For Public Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Needed For Public Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForPublicInterest()
	 * @see #getProcess()
	 * @generated
	 */
	EReference getProcess_NeededForPublicInterest();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegimateInterest <em>Needed For Legimate Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Needed For Legimate Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegimateInterest()
	 * @see #getProcess()
	 * @generated
	 */
	EReference getProcess_NeededForLegimateInterest();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegalObligation <em>Needed For Legal Obligation</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Needed For Legal Obligation</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegalObligation()
	 * @see #getProcess()
	 * @generated
	 */
	EReference getProcess_NeededForLegalObligation();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForVitalInterest <em>Needed For Vital Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Needed For Vital Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForVitalInterest()
	 * @see #getProcess()
	 * @generated
	 */
	EReference getProcess_NeededForVitalInterest();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData <em>Personal Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Personal Data</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData
	 * @generated
	 */
	EClass getPersonalData();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getRelatedTo <em>Related To</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Related To</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getRelatedTo()
	 * @see #getPersonalData()
	 * @generated
	 */
	EReference getPersonalData_RelatedTo();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getResponsible <em>Responsible</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Responsible</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getResponsible()
	 * @see #getPersonalData()
	 * @generated
	 */
	EReference getPersonalData_Responsible();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getProcessedBy <em>Processed By</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Processed By</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getProcessedBy()
	 * @see #getPersonalData()
	 * @generated
	 */
	EReference getPersonalData_ProcessedBy();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data <em>Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Data</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data
	 * @generated
	 */
	EClass getData();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data#getBase_NamedElement()
	 * @see #getData()
	 * @generated
	 */
	EReference getData_Base_NamedElement();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject <em>Data Subject</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Data Subject</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject
	 * @generated
	 */
	EClass getDataSubject();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getBase_NamedElement()
	 * @see #getDataSubject()
	 * @generated
	 */
	EReference getDataSubject_Base_NamedElement();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getGivenConsent <em>Given Consent</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Given Consent</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getGivenConsent()
	 * @see #getDataSubject()
	 * @generated
	 */
	EReference getDataSubject_GivenConsent();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getContract <em>Contract</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Contract</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getContract()
	 * @see #getDataSubject()
	 * @generated
	 */
	EReference getDataSubject_Contract();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getPersonalData <em>Personal Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Personal Data</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getPersonalData()
	 * @see #getDataSubject()
	 * @generated
	 */
	EReference getDataSubject_PersonalData();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent <em>Consent</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Consent</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent
	 * @generated
	 */
	EClass getConsent();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getBase_NamedElement()
	 * @see #getConsent()
	 * @generated
	 */
	EReference getConsent_Base_NamedElement();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getPurpose <em>Purpose</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Purpose</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getPurpose()
	 * @see #getConsent()
	 * @generated
	 */
	EReference getConsent_Purpose();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getDatasubject <em>Datasubject</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Datasubject</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getDatasubject()
	 * @see #getConsent()
	 * @generated
	 */
	EReference getConsent_Datasubject();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose <em>Purpose</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Purpose</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose
	 * @generated
	 */
	EClass getPurpose();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getBase_NamedElement()
	 * @see #getPurpose()
	 * @generated
	 */
	EReference getPurpose_Base_NamedElement();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getProcesses <em>Processes</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Processes</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getProcesses()
	 * @see #getPurpose()
	 * @generated
	 */
	EReference getPurpose_Processes();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getConsent <em>Consent</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Consent</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getConsent()
	 * @see #getPurpose()
	 * @generated
	 */
	EReference getPurpose_Consent();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract <em>Contract</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Contract</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract
	 * @generated
	 */
	EClass getContract();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getBase_NamedElement()
	 * @see #getContract()
	 * @generated
	 */
	EReference getContract_Base_NamedElement();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getProcess <em>Process</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Process</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getProcess()
	 * @see #getContract()
	 * @generated
	 */
	EReference getContract_Process();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getDatasubject <em>Datasubject</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Datasubject</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getDatasubject()
	 * @see #getContract()
	 * @generated
	 */
	EReference getContract_Datasubject();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller <em>Controller</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Controller</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller
	 * @generated
	 */
	EClass getController();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getProcessor <em>Processor</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Processor</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getProcessor()
	 * @see #getController()
	 * @generated
	 */
	EReference getController_Processor();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getBase_NamedElement()
	 * @see #getController()
	 * @generated
	 */
	EReference getController_Base_NamedElement();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getPersonalData <em>Personal Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Personal Data</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getPersonalData()
	 * @see #getController()
	 * @generated
	 */
	EReference getController_PersonalData();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor <em>Processor</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Processor</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor
	 * @generated
	 */
	EClass getProcessor();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getProcess <em>Process</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Process</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getProcess()
	 * @see #getProcessor()
	 * @generated
	 */
	EReference getProcessor_Process();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getBase_NamedElement()
	 * @see #getProcessor()
	 * @generated
	 */
	EReference getProcessor_Base_NamedElement();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest <em>Public Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Public Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest
	 * @generated
	 */
	EClass getPublicInterest();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest#getBase_NamedElement()
	 * @see #getPublicInterest()
	 * @generated
	 */
	EReference getPublicInterest_Base_NamedElement();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest <em>Legitimate Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Legitimate Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest
	 * @generated
	 */
	EClass getLegitimateInterest();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest#getBase_NamedElement()
	 * @see #getLegitimateInterest()
	 * @generated
	 */
	EReference getLegitimateInterest_Base_NamedElement();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation <em>Legal Obligation</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Legal Obligation</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation
	 * @generated
	 */
	EClass getLegalObligation();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation#getBase_NamedElement()
	 * @see #getLegalObligation()
	 * @generated
	 */
	EReference getLegalObligation_Base_NamedElement();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest <em>Vital Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Vital Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest
	 * @generated
	 */
	EClass getVitalInterest();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest#getBase_NamedElement <em>Base Named Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Named Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest#getBase_NamedElement()
	 * @see #getVitalInterest()
	 * @generated
	 */
	EReference getVitalInterest_Base_NamedElement();

	/**
	 * Returns the factory that creates the instances of the model.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the factory that creates the instances of the model.
	 * @generated
	 */
	Pdp4engCommonGDPRFactory getPdp4engCommonGDPRFactory();

	/**
	 * <!-- begin-user-doc -->
	 * Defines literals for the meta objects that represent
	 * <ul>
	 *   <li>each class,</li>
	 *   <li>each feature of each class,</li>
	 *   <li>each operation of each class,</li>
	 *   <li>each enum,</li>
	 *   <li>and each data type</li>
	 * </ul>
	 * <!-- end-user-doc -->
	 * @generated
	 */
	interface Literals {
		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl <em>Process</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getProcess()
		 * @generated
		 */
		EClass PROCESS = eINSTANCE.getProcess();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESS__BASE_NAMED_ELEMENT = eINSTANCE.getProcess_Base_NamedElement();

		/**
		 * The meta object literal for the '<em><b>Personaldata</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESS__PERSONALDATA = eINSTANCE.getProcess_Personaldata();

		/**
		 * The meta object literal for the '<em><b>Contributed To</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESS__CONTRIBUTED_TO = eINSTANCE.getProcess_ContributedTo();

		/**
		 * The meta object literal for the '<em><b>Perform AContract</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESS__PERFORM_ACONTRACT = eINSTANCE.getProcess_PerformAContract();

		/**
		 * The meta object literal for the '<em><b>Data</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESS__DATA = eINSTANCE.getProcess_Data();

		/**
		 * The meta object literal for the '<em><b>Needed For Public Interest</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESS__NEEDED_FOR_PUBLIC_INTEREST = eINSTANCE.getProcess_NeededForPublicInterest();

		/**
		 * The meta object literal for the '<em><b>Needed For Legimate Interest</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESS__NEEDED_FOR_LEGIMATE_INTEREST = eINSTANCE.getProcess_NeededForLegimateInterest();

		/**
		 * The meta object literal for the '<em><b>Needed For Legal Obligation</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESS__NEEDED_FOR_LEGAL_OBLIGATION = eINSTANCE.getProcess_NeededForLegalObligation();

		/**
		 * The meta object literal for the '<em><b>Needed For Vital Interest</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESS__NEEDED_FOR_VITAL_INTEREST = eINSTANCE.getProcess_NeededForVitalInterest();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl <em>Personal Data</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPersonalData()
		 * @generated
		 */
		EClass PERSONAL_DATA = eINSTANCE.getPersonalData();

		/**
		 * The meta object literal for the '<em><b>Related To</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PERSONAL_DATA__RELATED_TO = eINSTANCE.getPersonalData_RelatedTo();

		/**
		 * The meta object literal for the '<em><b>Responsible</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PERSONAL_DATA__RESPONSIBLE = eINSTANCE.getPersonalData_Responsible();

		/**
		 * The meta object literal for the '<em><b>Processed By</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PERSONAL_DATA__PROCESSED_BY = eINSTANCE.getPersonalData_ProcessedBy();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataImpl <em>Data</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getData()
		 * @generated
		 */
		EClass DATA = eINSTANCE.getData();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA__BASE_NAMED_ELEMENT = eINSTANCE.getData_Base_NamedElement();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl <em>Data Subject</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getDataSubject()
		 * @generated
		 */
		EClass DATA_SUBJECT = eINSTANCE.getDataSubject();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_SUBJECT__BASE_NAMED_ELEMENT = eINSTANCE.getDataSubject_Base_NamedElement();

		/**
		 * The meta object literal for the '<em><b>Given Consent</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_SUBJECT__GIVEN_CONSENT = eINSTANCE.getDataSubject_GivenConsent();

		/**
		 * The meta object literal for the '<em><b>Contract</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_SUBJECT__CONTRACT = eINSTANCE.getDataSubject_Contract();

		/**
		 * The meta object literal for the '<em><b>Personal Data</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_SUBJECT__PERSONAL_DATA = eINSTANCE.getDataSubject_PersonalData();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl <em>Consent</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getConsent()
		 * @generated
		 */
		EClass CONSENT = eINSTANCE.getConsent();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CONSENT__BASE_NAMED_ELEMENT = eINSTANCE.getConsent_Base_NamedElement();

		/**
		 * The meta object literal for the '<em><b>Purpose</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CONSENT__PURPOSE = eINSTANCE.getConsent_Purpose();

		/**
		 * The meta object literal for the '<em><b>Datasubject</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CONSENT__DATASUBJECT = eINSTANCE.getConsent_Datasubject();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl <em>Purpose</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPurpose()
		 * @generated
		 */
		EClass PURPOSE = eINSTANCE.getPurpose();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PURPOSE__BASE_NAMED_ELEMENT = eINSTANCE.getPurpose_Base_NamedElement();

		/**
		 * The meta object literal for the '<em><b>Processes</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PURPOSE__PROCESSES = eINSTANCE.getPurpose_Processes();

		/**
		 * The meta object literal for the '<em><b>Consent</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PURPOSE__CONSENT = eINSTANCE.getPurpose_Consent();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl <em>Contract</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getContract()
		 * @generated
		 */
		EClass CONTRACT = eINSTANCE.getContract();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CONTRACT__BASE_NAMED_ELEMENT = eINSTANCE.getContract_Base_NamedElement();

		/**
		 * The meta object literal for the '<em><b>Process</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CONTRACT__PROCESS = eINSTANCE.getContract_Process();

		/**
		 * The meta object literal for the '<em><b>Datasubject</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CONTRACT__DATASUBJECT = eINSTANCE.getContract_Datasubject();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl <em>Controller</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getController()
		 * @generated
		 */
		EClass CONTROLLER = eINSTANCE.getController();

		/**
		 * The meta object literal for the '<em><b>Processor</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CONTROLLER__PROCESSOR = eINSTANCE.getController_Processor();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CONTROLLER__BASE_NAMED_ELEMENT = eINSTANCE.getController_Base_NamedElement();

		/**
		 * The meta object literal for the '<em><b>Personal Data</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CONTROLLER__PERSONAL_DATA = eINSTANCE.getController_PersonalData();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl <em>Processor</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getProcessor()
		 * @generated
		 */
		EClass PROCESSOR = eINSTANCE.getProcessor();

		/**
		 * The meta object literal for the '<em><b>Process</b></em>' reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESSOR__PROCESS = eINSTANCE.getProcessor_Process();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESSOR__BASE_NAMED_ELEMENT = eINSTANCE.getProcessor_Base_NamedElement();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PublicInterestImpl <em>Public Interest</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PublicInterestImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPublicInterest()
		 * @generated
		 */
		EClass PUBLIC_INTEREST = eINSTANCE.getPublicInterest();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PUBLIC_INTEREST__BASE_NAMED_ELEMENT = eINSTANCE.getPublicInterest_Base_NamedElement();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegitimateInterestImpl <em>Legitimate Interest</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegitimateInterestImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getLegitimateInterest()
		 * @generated
		 */
		EClass LEGITIMATE_INTEREST = eINSTANCE.getLegitimateInterest();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT = eINSTANCE.getLegitimateInterest_Base_NamedElement();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegalObligationImpl <em>Legal Obligation</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegalObligationImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getLegalObligation()
		 * @generated
		 */
		EClass LEGAL_OBLIGATION = eINSTANCE.getLegalObligation();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference LEGAL_OBLIGATION__BASE_NAMED_ELEMENT = eINSTANCE.getLegalObligation_Base_NamedElement();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.VitalInterestImpl <em>Vital Interest</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.VitalInterestImpl
		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getVitalInterest()
		 * @generated
		 */
		EClass VITAL_INTEREST = eINSTANCE.getVitalInterest();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference VITAL_INTEREST__BASE_NAMED_ELEMENT = eINSTANCE.getVitalInterest_Base_NamedElement();

	}

} //Pdp4engCommonGDPRPackage
