/**
 *  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.req.profile.pdp4engReqGDPR;

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

import org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage;

/**
 * <!-- 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.req.profile.pdp4engReqGDPR.pdp4engReqGDPRFactory
 * @model kind="package"
 * @generated
 */
public interface pdp4engReqGDPRPackage extends EPackage {
	/**
	 * The package name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNAME = "pdp4engReqGDPR";

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

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

	/**
	 * The singleton instance of the package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	pdp4engReqGDPRPackage eINSTANCE = org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl.init();

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ProcessRequirementImpl <em>Process Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ProcessRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getProcessRequirement()
	 * @generated
	 */
	int PROCESS_REQUIREMENT = 0;

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

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

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

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

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

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

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

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

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

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.StakeholderImpl <em>Stakeholder</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.StakeholderImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getStakeholder()
	 * @generated
	 */
	int STAKEHOLDER = 1;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalDataRequirementImpl <em>Personal Data Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalDataRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPersonalDataRequirement()
	 * @generated
	 */
	int PERSONAL_DATA_REQUIREMENT = 2;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PERSONAL_DATA_REQUIREMENT__BASE_NAMED_ELEMENT = Pdp4engCommonGDPRPackage.PERSONAL_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_REQUIREMENT__RELATED_TO = Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO;

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

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

	/**
	 * The feature id for the '<em><b>Source</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PERSONAL_DATA_REQUIREMENT__SOURCE = Pdp4engCommonGDPRPackage.PERSONAL_DATA_FEATURE_COUNT + 0;

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.GDPRPrincipleImpl <em>GDPR Principle</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.GDPRPrincipleImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getGDPRPrinciple()
	 * @generated
	 */
	int GDPR_PRINCIPLE = 3;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ProcessPrincipleImpl <em>Process Principle</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ProcessPrincipleImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getProcessPrinciple()
	 * @generated
	 */
	int PROCESS_PRINCIPLE = 4;

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

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

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

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

	/**
	 * The number of structural features of the '<em>Process Principle</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS_PRINCIPLE_FEATURE_COUNT = GDPR_PRINCIPLE_FEATURE_COUNT + 3;

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PurposePersonalDataPrincipleImpl <em>Purpose Personal Data Principle</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PurposePersonalDataPrincipleImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPurposePersonalDataPrinciple()
	 * @generated
	 */
	int PURPOSE_PERSONAL_DATA_PRINCIPLE = 5;

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

	/**
	 * The feature id for the '<em><b>Purpose</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PURPOSE_PERSONAL_DATA_PRINCIPLE__PURPOSE = GDPR_PRINCIPLE_FEATURE_COUNT + 0;

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

	/**
	 * The number of structural features of the '<em>Purpose Personal Data Principle</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PURPOSE_PERSONAL_DATA_PRINCIPLE_FEATURE_COUNT = GDPR_PRINCIPLE_FEATURE_COUNT + 2;

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataMinimisationImpl <em>Data Minimisation</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataMinimisationImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataMinimisation()
	 * @generated
	 */
	int DATA_MINIMISATION = 6;

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

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

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

	/**
	 * The number of structural features of the '<em>Data Minimisation</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_MINIMISATION_FEATURE_COUNT = PURPOSE_PERSONAL_DATA_PRINCIPLE_FEATURE_COUNT + 0;

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PurposeLimitationImpl <em>Purpose Limitation</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PurposeLimitationImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPurposeLimitation()
	 * @generated
	 */
	int PURPOSE_LIMITATION = 7;

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

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

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

	/**
	 * The number of structural features of the '<em>Purpose Limitation</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PURPOSE_LIMITATION_FEATURE_COUNT = PURPOSE_PERSONAL_DATA_PRINCIPLE_FEATURE_COUNT + 0;

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AccuracyImpl <em>Accuracy</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AccuracyImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getAccuracy()
	 * @generated
	 */
	int ACCURACY = 8;

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

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

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

	/**
	 * The number of structural features of the '<em>Accuracy</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int ACCURACY_FEATURE_COUNT = PURPOSE_PERSONAL_DATA_PRINCIPLE_FEATURE_COUNT + 0;

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.StorageLimitationImpl <em>Storage Limitation</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.StorageLimitationImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getStorageLimitation()
	 * @generated
	 */
	int STORAGE_LIMITATION = 9;

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

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

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

	/**
	 * The number of structural features of the '<em>Storage Limitation</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int STORAGE_LIMITATION_FEATURE_COUNT = PURPOSE_PERSONAL_DATA_PRINCIPLE_FEATURE_COUNT + 0;

	/**
	 * The number of operations of the '<em>Storage Limitation</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int STORAGE_LIMITATION_OPERATION_COUNT = PURPOSE_PERSONAL_DATA_PRINCIPLE_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulImpl <em>Lawful</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawful()
	 * @generated
	 */
	int LAWFUL = 10;

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

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

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

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

	/**
	 * The number of structural features of the '<em>Lawful</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LAWFUL_FEATURE_COUNT = PROCESS_PRINCIPLE_FEATURE_COUNT + 0;

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.FairlyImpl <em>Fairly</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.FairlyImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getFairly()
	 * @generated
	 */
	int FAIRLY = 11;

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

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

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

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

	/**
	 * The number of structural features of the '<em>Fairly</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int FAIRLY_FEATURE_COUNT = PROCESS_PRINCIPLE_FEATURE_COUNT + 0;

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.TransparencyImpl <em>Transparency</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.TransparencyImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getTransparency()
	 * @generated
	 */
	int TRANSPARENCY = 12;

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

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

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

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

	/**
	 * The number of structural features of the '<em>Transparency</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int TRANSPARENCY_FEATURE_COUNT = PROCESS_PRINCIPLE_FEATURE_COUNT + 0;

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.SecuritySafetyImpl <em>Security Safety</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.SecuritySafetyImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getSecuritySafety()
	 * @generated
	 */
	int SECURITY_SAFETY = 13;

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

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

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

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

	/**
	 * The number of structural features of the '<em>Security Safety</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SECURITY_SAFETY_FEATURE_COUNT = PROCESS_PRINCIPLE_FEATURE_COUNT + 0;

	/**
	 * The number of operations of the '<em>Security Safety</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SECURITY_SAFETY_OPERATION_COUNT = PROCESS_PRINCIPLE_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.RelatedToImpl <em>Related To</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.RelatedToImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getRelatedTo()
	 * @generated
	 */
	int RELATED_TO = 14;

	/**
	 * The feature id for the '<em><b>Sensitive</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RELATED_TO__SENSITIVE = 0;

	/**
	 * The feature id for the '<em><b>Linkability</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RELATED_TO__LINKABILITY = 1;

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

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableAtImpl <em>Available At</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableAtImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getAvailableAt()
	 * @generated
	 */
	int AVAILABLE_AT = 15;

	/**
	 * The feature id for the '<em><b>Duration</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int AVAILABLE_AT__DURATION = 0;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DerivedFromImpl <em>Derived From</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DerivedFromImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDerivedFrom()
	 * @generated
	 */
	int DERIVED_FROM = 16;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRequirementImpl <em>Data Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataRequirement()
	 * @generated
	 */
	int DATA_REQUIREMENT = 17;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LinkableImpl <em>Linkable</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LinkableImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLinkable()
	 * @generated
	 */
	int LINKABLE = 18;

	/**
	 * The feature id for the '<em><b>Duration</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LINKABLE__DURATION = 0;

	/**
	 * The feature id for the '<em><b>Linkability</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LINKABLE__LINKABILITY = 1;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.GeneratedRequirementsImpl <em>Generated Requirements</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.GeneratedRequirementsImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getGeneratedRequirements()
	 * @generated
	 */
	int GENERATED_REQUIREMENTS = 19;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataFlowRequirementImpl <em>Data Flow Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataFlowRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataFlowRequirement()
	 * @generated
	 */
	int DATA_FLOW_REQUIREMENT = 20;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataSubjectsImpl <em>Data Subjects</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataSubjectsImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataSubjects()
	 * @generated
	 */
	int DATA_SUBJECTS = 21;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRequirementsImpl <em>Data Requirements</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRequirementsImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataRequirements()
	 * @generated
	 */
	int DATA_REQUIREMENTS = 22;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableInformationImpl <em>Available Information</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableInformationImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getAvailableInformation()
	 * @generated
	 */
	int AVAILABLE_INFORMATION = 23;

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

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalInformationImpl <em>Personal Information</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalInformationImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPersonalInformation()
	 * @generated
	 */
	int PERSONAL_INFORMATION = 24;

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

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableInformationContainerImpl <em>Available Information Container</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableInformationContainerImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getAvailableInformationContainer()
	 * @generated
	 */
	int AVAILABLE_INFORMATION_CONTAINER = 25;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalInformationContainerImpl <em>Personal Information Container</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalInformationContainerImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPersonalInformationContainer()
	 * @generated
	 */
	int PERSONAL_INFORMATION_CONTAINER = 26;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PrivacyRequirementImpl <em>Privacy Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PrivacyRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPrivacyRequirement()
	 * @generated
	 */
	int PRIVACY_REQUIREMENT = 28;

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

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

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

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.UnlinkabilityRequirementImpl <em>Unlinkability Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.UnlinkabilityRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getUnlinkabilityRequirement()
	 * @generated
	 */
	int UNLINKABILITY_REQUIREMENT = 27;

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

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

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

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

	/**
	 * The feature id for the '<em><b>Linkability</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int UNLINKABILITY_REQUIREMENT__LINKABILITY = PRIVACY_REQUIREMENT_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Unlinkability Requirement</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int UNLINKABILITY_REQUIREMENT_FEATURE_COUNT = PRIVACY_REQUIREMENT_FEATURE_COUNT + 1;

	/**
	 * The number of operations of the '<em>Unlinkability Requirement</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int UNLINKABILITY_REQUIREMENT_OPERATION_COUNT = PRIVACY_REQUIREMENT_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataUnlinkabilityRequirementImpl <em>Data Unlinkability Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataUnlinkabilityRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataUnlinkabilityRequirement()
	 * @generated
	 */
	int DATA_UNLINKABILITY_REQUIREMENT = 29;

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

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

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

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

	/**
	 * The feature id for the '<em><b>Linkability</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_UNLINKABILITY_REQUIREMENT__LINKABILITY = UNLINKABILITY_REQUIREMENT__LINKABILITY;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ControlersImpl <em>Controlers</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ControlersImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getControlers()
	 * @generated
	 */
	int CONTROLERS = 30;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LinkImpl <em>Link</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LinkImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLink()
	 * @generated
	 */
	int LINK = 31;

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

	/**
	 * The feature id for the '<em><b>Linkability</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LINK__LINKABILITY = 1;

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.UndectabilityRequirementImpl <em>Undectability Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.UndectabilityRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getUndectabilityRequirement()
	 * @generated
	 */
	int UNDECTABILITY_REQUIREMENT = 32;

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

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

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

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

	/**
	 * The number of structural features of the '<em>Undectability Requirement</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int UNDECTABILITY_REQUIREMENT_FEATURE_COUNT = PRIVACY_REQUIREMENT_FEATURE_COUNT + 0;

	/**
	 * The number of operations of the '<em>Undectability Requirement</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int UNDECTABILITY_REQUIREMENT_OPERATION_COUNT = PRIVACY_REQUIREMENT_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PseudonimityRequirementImpl <em>Pseudonimity Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PseudonimityRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPseudonimityRequirement()
	 * @generated
	 */
	int PSEUDONIMITY_REQUIREMENT = 33;

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

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

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

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

	/**
	 * The feature id for the '<em><b>Kind</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PSEUDONIMITY_REQUIREMENT__KIND = PRIVACY_REQUIREMENT_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Pseudonimity Requirement</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PSEUDONIMITY_REQUIREMENT_FEATURE_COUNT = PRIVACY_REQUIREMENT_FEATURE_COUNT + 1;

	/**
	 * The number of operations of the '<em>Pseudonimity Requirement</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PSEUDONIMITY_REQUIREMENT_OPERATION_COUNT = PRIVACY_REQUIREMENT_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AnanomityRequirementImpl <em>Ananomity Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AnanomityRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getAnanomityRequirement()
	 * @generated
	 */
	int ANANOMITY_REQUIREMENT = 34;

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

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

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

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

	/**
	 * The feature id for the '<em><b>Linkability</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int ANANOMITY_REQUIREMENT__LINKABILITY = UNLINKABILITY_REQUIREMENT__LINKABILITY;

	/**
	 * The number of structural features of the '<em>Ananomity Requirement</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int ANANOMITY_REQUIREMENT_FEATURE_COUNT = UNLINKABILITY_REQUIREMENT_FEATURE_COUNT + 0;

	/**
	 * The number of operations of the '<em>Ananomity Requirement</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int ANANOMITY_REQUIREMENT_OPERATION_COUNT = UNLINKABILITY_REQUIREMENT_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRecordRequirementImpl <em>Data Record Requirement</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRecordRequirementImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataRecordRequirement()
	 * @generated
	 */
	int DATA_RECORD_REQUIREMENT = 35;

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

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.FunctionalRequirementsImpl <em>Functional Requirements</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.FunctionalRequirementsImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getFunctionalRequirements()
	 * @generated
	 */
	int FUNCTIONAL_REQUIREMENTS = 36;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.NonFunctionalRequirementsImpl <em>Non Functional Requirements</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.NonFunctionalRequirementsImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getNonFunctionalRequirements()
	 * @generated
	 */
	int NON_FUNCTIONAL_REQUIREMENTS = 37;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByConsentImpl <em>Lawful By Consent</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByConsentImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByConsent()
	 * @generated
	 */
	int LAWFUL_BY_CONSENT = 38;

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

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

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

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

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

	/**
	 * The number of structural features of the '<em>Lawful By Consent</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LAWFUL_BY_CONSENT_FEATURE_COUNT = LAWFUL_FEATURE_COUNT + 1;

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByContractImpl <em>Lawful By Contract</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByContractImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByContract()
	 * @generated
	 */
	int LAWFUL_BY_CONTRACT = 39;

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

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

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

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

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

	/**
	 * The number of structural features of the '<em>Lawful By Contract</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LAWFUL_BY_CONTRACT_FEATURE_COUNT = LAWFUL_FEATURE_COUNT + 1;

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByPublicInterestImpl <em>Lawful By Public Interest</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByPublicInterestImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByPublicInterest()
	 * @generated
	 */
	int LAWFUL_BY_PUBLIC_INTEREST = 40;

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

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

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

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

	/**
	 * The feature id for the '<em><b>Public Interest</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LAWFUL_BY_PUBLIC_INTEREST__PUBLIC_INTEREST = LAWFUL_FEATURE_COUNT + 0;

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByLegitimateInterestImpl <em>Lawful By Legitimate Interest</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByLegitimateInterestImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByLegitimateInterest()
	 * @generated
	 */
	int LAWFUL_BY_LEGITIMATE_INTEREST = 41;

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

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

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

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

	/**
	 * The feature id for the '<em><b>Legitimate Interest</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LAWFUL_BY_LEGITIMATE_INTEREST__LEGITIMATE_INTEREST = LAWFUL_FEATURE_COUNT + 0;

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByLegalObligationImpl <em>Lawful By Legal Obligation</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByLegalObligationImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByLegalObligation()
	 * @generated
	 */
	int LAWFUL_BY_LEGAL_OBLIGATION = 42;

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

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

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

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

	/**
	 * The feature id for the '<em><b>Legal Obligation</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LAWFUL_BY_LEGAL_OBLIGATION__LEGAL_OBLIGATION = LAWFUL_FEATURE_COUNT + 0;

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByVitalInterestImpl <em>Lawful By Vital Interest</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByVitalInterestImpl
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByVitalInterest()
	 * @generated
	 */
	int LAWFUL_BY_VITAL_INTEREST = 43;

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

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

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

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

	/**
	 * The feature id for the '<em><b>Vital Interest</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LAWFUL_BY_VITAL_INTEREST__VITAL_INTEREST = LAWFUL_FEATURE_COUNT + 0;

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability <em>Linkability</em>}' enum.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLinkability()
	 * @generated
	 */
	int LINKABILITY = 44;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.CollectionMethod <em>Collection Method</em>}' enum.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.CollectionMethod
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getCollectionMethod()
	 * @generated
	 */
	int COLLECTION_METHOD = 45;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Duration <em>Duration</em>}' enum.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Duration
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDuration()
	 * @generated
	 */
	int DURATION = 46;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonymKind <em>Pseudonym Kind</em>}' enum.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonymKind
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPseudonymKind()
	 * @generated
	 */
	int PSEUDONYM_KIND = 47;


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

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessRequirement#getRequester <em>Requester</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Requester</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessRequirement#getRequester()
	 * @see #getProcessRequirement()
	 * @generated
	 */
	EReference getProcessRequirement_Requester();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Stakeholder#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.req.profile.pdp4engReqGDPR.Stakeholder#getBase_NamedElement()
	 * @see #getStakeholder()
	 * @generated
	 */
	EReference getStakeholder_Base_NamedElement();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalDataRequirement#getSource <em>Source</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Source</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalDataRequirement#getSource()
	 * @see #getPersonalDataRequirement()
	 * @generated
	 */
	EReference getPersonalDataRequirement_Source();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GDPRPrinciple <em>GDPR Principle</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>GDPR Principle</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GDPRPrinciple
	 * @generated
	 */
	EClass getGDPRPrinciple();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GDPRPrinciple#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.req.profile.pdp4engReqGDPR.GDPRPrinciple#getBase_NamedElement()
	 * @see #getGDPRPrinciple()
	 * @generated
	 */
	EReference getGDPRPrinciple_Base_NamedElement();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessPrinciple#getProcess <em>Process</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Process</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessPrinciple#getProcess()
	 * @see #getProcessPrinciple()
	 * @generated
	 */
	EReference getProcessPrinciple_Process();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessPrinciple#getDataSubject <em>Data Subject</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Data Subject</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessPrinciple#getDataSubject()
	 * @see #getProcessPrinciple()
	 * @generated
	 */
	EReference getProcessPrinciple_DataSubject();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessPrinciple#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.req.profile.pdp4engReqGDPR.ProcessPrinciple#getPersonalData()
	 * @see #getProcessPrinciple()
	 * @generated
	 */
	EReference getProcessPrinciple_PersonalData();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposePersonalDataPrinciple <em>Purpose Personal Data Principle</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Purpose Personal Data Principle</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposePersonalDataPrinciple
	 * @generated
	 */
	EClass getPurposePersonalDataPrinciple();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposePersonalDataPrinciple#getPurpose <em>Purpose</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Purpose</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposePersonalDataPrinciple#getPurpose()
	 * @see #getPurposePersonalDataPrinciple()
	 * @generated
	 */
	EReference getPurposePersonalDataPrinciple_Purpose();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposePersonalDataPrinciple#getPersonalData <em>Personal Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Personal Data</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposePersonalDataPrinciple#getPersonalData()
	 * @see #getPurposePersonalDataPrinciple()
	 * @generated
	 */
	EReference getPurposePersonalDataPrinciple_PersonalData();

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

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

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

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.StorageLimitation <em>Storage Limitation</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Storage Limitation</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.StorageLimitation
	 * @generated
	 */
	EClass getStorageLimitation();

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

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

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

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.SecuritySafety <em>Security Safety</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Security Safety</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.SecuritySafety
	 * @generated
	 */
	EClass getSecuritySafety();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo <em>Related To</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Related To</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo
	 * @generated
	 */
	EClass getRelatedTo();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo#isSensitive <em>Sensitive</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Sensitive</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo#isSensitive()
	 * @see #getRelatedTo()
	 * @generated
	 */
	EAttribute getRelatedTo_Sensitive();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo#getLinkability <em>Linkability</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Linkability</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo#getLinkability()
	 * @see #getRelatedTo()
	 * @generated
	 */
	EAttribute getRelatedTo_Linkability();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo#getCollection <em>Collection</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Collection</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo#getCollection()
	 * @see #getRelatedTo()
	 * @generated
	 */
	EAttribute getRelatedTo_Collection();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo#getBase_Element <em>Base Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo#getBase_Element()
	 * @see #getRelatedTo()
	 * @generated
	 */
	EReference getRelatedTo_Base_Element();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableAt <em>Available At</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Available At</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableAt
	 * @generated
	 */
	EClass getAvailableAt();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableAt#getDuration <em>Duration</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Duration</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableAt#getDuration()
	 * @see #getAvailableAt()
	 * @generated
	 */
	EAttribute getAvailableAt_Duration();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableAt#getBase_Element <em>Base Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableAt#getBase_Element()
	 * @see #getAvailableAt()
	 * @generated
	 */
	EReference getAvailableAt_Base_Element();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DerivedFrom <em>Derived From</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Derived From</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DerivedFrom
	 * @generated
	 */
	EClass getDerivedFrom();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DerivedFrom#getBase_Element <em>Base Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DerivedFrom#getBase_Element()
	 * @see #getDerivedFrom()
	 * @generated
	 */
	EReference getDerivedFrom_Base_Element();

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

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

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkable#getDuration <em>Duration</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Duration</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkable#getDuration()
	 * @see #getLinkable()
	 * @generated
	 */
	EAttribute getLinkable_Duration();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkable#getLinkability <em>Linkability</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Linkability</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkable#getLinkability()
	 * @see #getLinkable()
	 * @generated
	 */
	EAttribute getLinkable_Linkability();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkable#getBase_Element <em>Base Element</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Element</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkable#getBase_Element()
	 * @see #getLinkable()
	 * @generated
	 */
	EReference getLinkable_Base_Element();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GeneratedRequirements <em>Generated Requirements</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Generated Requirements</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GeneratedRequirements
	 * @generated
	 */
	EClass getGeneratedRequirements();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GeneratedRequirements#getBase_Package <em>Base Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Package</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GeneratedRequirements#getBase_Package()
	 * @see #getGeneratedRequirements()
	 * @generated
	 */
	EReference getGeneratedRequirements_Base_Package();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataFlowRequirement#getBase_Activity <em>Base Activity</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Activity</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataFlowRequirement#getBase_Activity()
	 * @see #getDataFlowRequirement()
	 * @generated
	 */
	EReference getDataFlowRequirement_Base_Activity();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataSubjects#getBase_Package <em>Base Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Package</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataSubjects#getBase_Package()
	 * @see #getDataSubjects()
	 * @generated
	 */
	EReference getDataSubjects_Base_Package();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRequirements#getBase_Package <em>Base Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Package</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRequirements#getBase_Package()
	 * @see #getDataRequirements()
	 * @generated
	 */
	EReference getDataRequirements_Base_Package();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformation <em>Available Information</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Available Information</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformation
	 * @generated
	 */
	EClass getAvailableInformation();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformation#getBase_Package <em>Base Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Package</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformation#getBase_Package()
	 * @see #getAvailableInformation()
	 * @generated
	 */
	EReference getAvailableInformation_Base_Package();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformation#getConcerns <em>Concerns</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Concerns</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformation#getConcerns()
	 * @see #getAvailableInformation()
	 * @generated
	 */
	EReference getAvailableInformation_Concerns();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformation <em>Personal Information</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Personal Information</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformation
	 * @generated
	 */
	EClass getPersonalInformation();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformation#getBase_Package <em>Base Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Package</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformation#getBase_Package()
	 * @see #getPersonalInformation()
	 * @generated
	 */
	EReference getPersonalInformation_Base_Package();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformation#getConcerns <em>Concerns</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Concerns</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformation#getConcerns()
	 * @see #getPersonalInformation()
	 * @generated
	 */
	EReference getPersonalInformation_Concerns();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformationContainer <em>Available Information Container</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Available Information Container</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformationContainer
	 * @generated
	 */
	EClass getAvailableInformationContainer();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformationContainer#getBase_Package <em>Base Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Package</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformationContainer#getBase_Package()
	 * @see #getAvailableInformationContainer()
	 * @generated
	 */
	EReference getAvailableInformationContainer_Base_Package();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformationContainer <em>Personal Information Container</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Personal Information Container</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformationContainer
	 * @generated
	 */
	EClass getPersonalInformationContainer();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformationContainer#getBase_Package <em>Base Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Package</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformationContainer#getBase_Package()
	 * @see #getPersonalInformationContainer()
	 * @generated
	 */
	EReference getPersonalInformationContainer_Base_Package();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.UnlinkabilityRequirement <em>Unlinkability Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Unlinkability Requirement</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.UnlinkabilityRequirement
	 * @generated
	 */
	EClass getUnlinkabilityRequirement();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.UnlinkabilityRequirement#getLinkability <em>Linkability</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Linkability</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.UnlinkabilityRequirement#getLinkability()
	 * @see #getUnlinkabilityRequirement()
	 * @generated
	 */
	EAttribute getUnlinkabilityRequirement_Linkability();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PrivacyRequirement <em>Privacy Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Privacy Requirement</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PrivacyRequirement
	 * @generated
	 */
	EClass getPrivacyRequirement();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PrivacyRequirement#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.req.profile.pdp4engReqGDPR.PrivacyRequirement#getBase_NamedElement()
	 * @see #getPrivacyRequirement()
	 * @generated
	 */
	EReference getPrivacyRequirement_Base_NamedElement();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PrivacyRequirement#getDataSubject <em>Data Subject</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Data Subject</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PrivacyRequirement#getDataSubject()
	 * @see #getPrivacyRequirement()
	 * @generated
	 */
	EReference getPrivacyRequirement_DataSubject();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PrivacyRequirement#getCounterstakeholders <em>Counterstakeholders</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Counterstakeholders</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PrivacyRequirement#getCounterstakeholders()
	 * @see #getPrivacyRequirement()
	 * @generated
	 */
	EReference getPrivacyRequirement_Counterstakeholders();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PrivacyRequirement#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.req.profile.pdp4engReqGDPR.PrivacyRequirement#getPersonalData()
	 * @see #getPrivacyRequirement()
	 * @generated
	 */
	EReference getPrivacyRequirement_PersonalData();

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

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataUnlinkabilityRequirement#getLinks <em>Links</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Links</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataUnlinkabilityRequirement#getLinks()
	 * @see #getDataUnlinkabilityRequirement()
	 * @generated
	 */
	EReference getDataUnlinkabilityRequirement_Links();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Controlers#getBase_Package <em>Base Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Package</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Controlers#getBase_Package()
	 * @see #getControlers()
	 * @generated
	 */
	EReference getControlers_Base_Package();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Link#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.req.profile.pdp4engReqGDPR.Link#getBase_NamedElement()
	 * @see #getLink()
	 * @generated
	 */
	EReference getLink_Base_NamedElement();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Link#getLinkability <em>Linkability</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Linkability</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Link#getLinkability()
	 * @see #getLink()
	 * @generated
	 */
	EAttribute getLink_Linkability();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.UndectabilityRequirement <em>Undectability Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Undectability Requirement</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.UndectabilityRequirement
	 * @generated
	 */
	EClass getUndectabilityRequirement();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonimityRequirement <em>Pseudonimity Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Pseudonimity Requirement</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonimityRequirement
	 * @generated
	 */
	EClass getPseudonimityRequirement();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonimityRequirement#getKind <em>Kind</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Kind</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonimityRequirement#getKind()
	 * @see #getPseudonimityRequirement()
	 * @generated
	 */
	EAttribute getPseudonimityRequirement_Kind();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AnanomityRequirement <em>Ananomity Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Ananomity Requirement</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AnanomityRequirement
	 * @generated
	 */
	EClass getAnanomityRequirement();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRecordRequirement#getBase_DataStoreNode <em>Base Data Store Node</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Data Store Node</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRecordRequirement#getBase_DataStoreNode()
	 * @see #getDataRecordRequirement()
	 * @generated
	 */
	EReference getDataRecordRequirement_Base_DataStoreNode();

	/**
	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRecordRequirement#getDataList <em>Data List</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference list '<em>Data List</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRecordRequirement#getDataList()
	 * @see #getDataRecordRequirement()
	 * @generated
	 */
	EReference getDataRecordRequirement_DataList();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.FunctionalRequirements <em>Functional Requirements</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Functional Requirements</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.FunctionalRequirements
	 * @generated
	 */
	EClass getFunctionalRequirements();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.FunctionalRequirements#getBase_Package <em>Base Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Package</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.FunctionalRequirements#getBase_Package()
	 * @see #getFunctionalRequirements()
	 * @generated
	 */
	EReference getFunctionalRequirements_Base_Package();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.NonFunctionalRequirements <em>Non Functional Requirements</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Non Functional Requirements</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.NonFunctionalRequirements
	 * @generated
	 */
	EClass getNonFunctionalRequirements();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.NonFunctionalRequirements#getBase_Package <em>Base Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Package</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.NonFunctionalRequirements#getBase_Package()
	 * @see #getNonFunctionalRequirements()
	 * @generated
	 */
	EReference getNonFunctionalRequirements_Base_Package();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByConsent#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.req.profile.pdp4engReqGDPR.LawfulByConsent#getConsent()
	 * @see #getLawfulByConsent()
	 * @generated
	 */
	EReference getLawfulByConsent_Consent();

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

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByContract#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.req.profile.pdp4engReqGDPR.LawfulByContract#getContract()
	 * @see #getLawfulByContract()
	 * @generated
	 */
	EReference getLawfulByContract_Contract();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByPublicInterest <em>Lawful By Public Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Lawful By Public Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByPublicInterest
	 * @generated
	 */
	EClass getLawfulByPublicInterest();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByPublicInterest#getPublicInterest <em>Public Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Public Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByPublicInterest#getPublicInterest()
	 * @see #getLawfulByPublicInterest()
	 * @generated
	 */
	EReference getLawfulByPublicInterest_PublicInterest();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegitimateInterest <em>Lawful By Legitimate Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Lawful By Legitimate Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegitimateInterest
	 * @generated
	 */
	EClass getLawfulByLegitimateInterest();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegitimateInterest#getLegitimateInterest <em>Legitimate Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Legitimate Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegitimateInterest#getLegitimateInterest()
	 * @see #getLawfulByLegitimateInterest()
	 * @generated
	 */
	EReference getLawfulByLegitimateInterest_LegitimateInterest();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegalObligation <em>Lawful By Legal Obligation</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Lawful By Legal Obligation</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegalObligation
	 * @generated
	 */
	EClass getLawfulByLegalObligation();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegalObligation#getLegalObligation <em>Legal Obligation</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Legal Obligation</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegalObligation#getLegalObligation()
	 * @see #getLawfulByLegalObligation()
	 * @generated
	 */
	EReference getLawfulByLegalObligation_LegalObligation();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByVitalInterest <em>Lawful By Vital Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Lawful By Vital Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByVitalInterest
	 * @generated
	 */
	EClass getLawfulByVitalInterest();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByVitalInterest#getVitalInterest <em>Vital Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Vital Interest</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByVitalInterest#getVitalInterest()
	 * @see #getLawfulByVitalInterest()
	 * @generated
	 */
	EReference getLawfulByVitalInterest_VitalInterest();

	/**
	 * Returns the meta object for enum '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability <em>Linkability</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for enum '<em>Linkability</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability
	 * @generated
	 */
	EEnum getLinkability();

	/**
	 * Returns the meta object for enum '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.CollectionMethod <em>Collection Method</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for enum '<em>Collection Method</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.CollectionMethod
	 * @generated
	 */
	EEnum getCollectionMethod();

	/**
	 * Returns the meta object for enum '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Duration <em>Duration</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for enum '<em>Duration</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Duration
	 * @generated
	 */
	EEnum getDuration();

	/**
	 * Returns the meta object for enum '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonymKind <em>Pseudonym Kind</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for enum '<em>Pseudonym Kind</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonymKind
	 * @generated
	 */
	EEnum getPseudonymKind();

	/**
	 * 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
	 */
	pdp4engReqGDPRFactory getpdp4engReqGDPRFactory();

	/**
	 * <!-- 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.req.profile.pdp4engReqGDPR.impl.ProcessRequirementImpl <em>Process Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ProcessRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getProcessRequirement()
		 * @generated
		 */
		EClass PROCESS_REQUIREMENT = eINSTANCE.getProcessRequirement();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.StakeholderImpl <em>Stakeholder</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.StakeholderImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getStakeholder()
		 * @generated
		 */
		EClass STAKEHOLDER = eINSTANCE.getStakeholder();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalDataRequirementImpl <em>Personal Data Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalDataRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPersonalDataRequirement()
		 * @generated
		 */
		EClass PERSONAL_DATA_REQUIREMENT = eINSTANCE.getPersonalDataRequirement();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.GDPRPrincipleImpl <em>GDPR Principle</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.GDPRPrincipleImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getGDPRPrinciple()
		 * @generated
		 */
		EClass GDPR_PRINCIPLE = eINSTANCE.getGDPRPrinciple();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ProcessPrincipleImpl <em>Process Principle</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ProcessPrincipleImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getProcessPrinciple()
		 * @generated
		 */
		EClass PROCESS_PRINCIPLE = eINSTANCE.getProcessPrinciple();

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

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PurposePersonalDataPrincipleImpl <em>Purpose Personal Data Principle</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PurposePersonalDataPrincipleImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPurposePersonalDataPrinciple()
		 * @generated
		 */
		EClass PURPOSE_PERSONAL_DATA_PRINCIPLE = eINSTANCE.getPurposePersonalDataPrinciple();

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataMinimisationImpl <em>Data Minimisation</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataMinimisationImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataMinimisation()
		 * @generated
		 */
		EClass DATA_MINIMISATION = eINSTANCE.getDataMinimisation();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PurposeLimitationImpl <em>Purpose Limitation</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PurposeLimitationImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPurposeLimitation()
		 * @generated
		 */
		EClass PURPOSE_LIMITATION = eINSTANCE.getPurposeLimitation();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AccuracyImpl <em>Accuracy</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AccuracyImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getAccuracy()
		 * @generated
		 */
		EClass ACCURACY = eINSTANCE.getAccuracy();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.StorageLimitationImpl <em>Storage Limitation</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.StorageLimitationImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getStorageLimitation()
		 * @generated
		 */
		EClass STORAGE_LIMITATION = eINSTANCE.getStorageLimitation();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulImpl <em>Lawful</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawful()
		 * @generated
		 */
		EClass LAWFUL = eINSTANCE.getLawful();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.FairlyImpl <em>Fairly</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.FairlyImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getFairly()
		 * @generated
		 */
		EClass FAIRLY = eINSTANCE.getFairly();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.TransparencyImpl <em>Transparency</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.TransparencyImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getTransparency()
		 * @generated
		 */
		EClass TRANSPARENCY = eINSTANCE.getTransparency();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.SecuritySafetyImpl <em>Security Safety</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.SecuritySafetyImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getSecuritySafety()
		 * @generated
		 */
		EClass SECURITY_SAFETY = eINSTANCE.getSecuritySafety();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.RelatedToImpl <em>Related To</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.RelatedToImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getRelatedTo()
		 * @generated
		 */
		EClass RELATED_TO = eINSTANCE.getRelatedTo();

		/**
		 * The meta object literal for the '<em><b>Sensitive</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute RELATED_TO__SENSITIVE = eINSTANCE.getRelatedTo_Sensitive();

		/**
		 * The meta object literal for the '<em><b>Linkability</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute RELATED_TO__LINKABILITY = eINSTANCE.getRelatedTo_Linkability();

		/**
		 * The meta object literal for the '<em><b>Collection</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute RELATED_TO__COLLECTION = eINSTANCE.getRelatedTo_Collection();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableAtImpl <em>Available At</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableAtImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getAvailableAt()
		 * @generated
		 */
		EClass AVAILABLE_AT = eINSTANCE.getAvailableAt();

		/**
		 * The meta object literal for the '<em><b>Duration</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute AVAILABLE_AT__DURATION = eINSTANCE.getAvailableAt_Duration();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DerivedFromImpl <em>Derived From</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DerivedFromImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDerivedFrom()
		 * @generated
		 */
		EClass DERIVED_FROM = eINSTANCE.getDerivedFrom();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRequirementImpl <em>Data Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataRequirement()
		 * @generated
		 */
		EClass DATA_REQUIREMENT = eINSTANCE.getDataRequirement();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LinkableImpl <em>Linkable</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LinkableImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLinkable()
		 * @generated
		 */
		EClass LINKABLE = eINSTANCE.getLinkable();

		/**
		 * The meta object literal for the '<em><b>Duration</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute LINKABLE__DURATION = eINSTANCE.getLinkable_Duration();

		/**
		 * The meta object literal for the '<em><b>Linkability</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute LINKABLE__LINKABILITY = eINSTANCE.getLinkable_Linkability();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.GeneratedRequirementsImpl <em>Generated Requirements</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.GeneratedRequirementsImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getGeneratedRequirements()
		 * @generated
		 */
		EClass GENERATED_REQUIREMENTS = eINSTANCE.getGeneratedRequirements();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataFlowRequirementImpl <em>Data Flow Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataFlowRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataFlowRequirement()
		 * @generated
		 */
		EClass DATA_FLOW_REQUIREMENT = eINSTANCE.getDataFlowRequirement();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataSubjectsImpl <em>Data Subjects</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataSubjectsImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataSubjects()
		 * @generated
		 */
		EClass DATA_SUBJECTS = eINSTANCE.getDataSubjects();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRequirementsImpl <em>Data Requirements</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRequirementsImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataRequirements()
		 * @generated
		 */
		EClass DATA_REQUIREMENTS = eINSTANCE.getDataRequirements();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableInformationImpl <em>Available Information</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableInformationImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getAvailableInformation()
		 * @generated
		 */
		EClass AVAILABLE_INFORMATION = eINSTANCE.getAvailableInformation();

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalInformationImpl <em>Personal Information</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalInformationImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPersonalInformation()
		 * @generated
		 */
		EClass PERSONAL_INFORMATION = eINSTANCE.getPersonalInformation();

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableInformationContainerImpl <em>Available Information Container</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AvailableInformationContainerImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getAvailableInformationContainer()
		 * @generated
		 */
		EClass AVAILABLE_INFORMATION_CONTAINER = eINSTANCE.getAvailableInformationContainer();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalInformationContainerImpl <em>Personal Information Container</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PersonalInformationContainerImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPersonalInformationContainer()
		 * @generated
		 */
		EClass PERSONAL_INFORMATION_CONTAINER = eINSTANCE.getPersonalInformationContainer();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.UnlinkabilityRequirementImpl <em>Unlinkability Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.UnlinkabilityRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getUnlinkabilityRequirement()
		 * @generated
		 */
		EClass UNLINKABILITY_REQUIREMENT = eINSTANCE.getUnlinkabilityRequirement();

		/**
		 * The meta object literal for the '<em><b>Linkability</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute UNLINKABILITY_REQUIREMENT__LINKABILITY = eINSTANCE.getUnlinkabilityRequirement_Linkability();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PrivacyRequirementImpl <em>Privacy Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PrivacyRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPrivacyRequirement()
		 * @generated
		 */
		EClass PRIVACY_REQUIREMENT = eINSTANCE.getPrivacyRequirement();

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

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

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataUnlinkabilityRequirementImpl <em>Data Unlinkability Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataUnlinkabilityRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataUnlinkabilityRequirement()
		 * @generated
		 */
		EClass DATA_UNLINKABILITY_REQUIREMENT = eINSTANCE.getDataUnlinkabilityRequirement();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ControlersImpl <em>Controlers</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.ControlersImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getControlers()
		 * @generated
		 */
		EClass CONTROLERS = eINSTANCE.getControlers();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LinkImpl <em>Link</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LinkImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLink()
		 * @generated
		 */
		EClass LINK = eINSTANCE.getLink();

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

		/**
		 * The meta object literal for the '<em><b>Linkability</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute LINK__LINKABILITY = eINSTANCE.getLink_Linkability();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.UndectabilityRequirementImpl <em>Undectability Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.UndectabilityRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getUndectabilityRequirement()
		 * @generated
		 */
		EClass UNDECTABILITY_REQUIREMENT = eINSTANCE.getUndectabilityRequirement();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PseudonimityRequirementImpl <em>Pseudonimity Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.PseudonimityRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPseudonimityRequirement()
		 * @generated
		 */
		EClass PSEUDONIMITY_REQUIREMENT = eINSTANCE.getPseudonimityRequirement();

		/**
		 * The meta object literal for the '<em><b>Kind</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute PSEUDONIMITY_REQUIREMENT__KIND = eINSTANCE.getPseudonimityRequirement_Kind();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AnanomityRequirementImpl <em>Ananomity Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.AnanomityRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getAnanomityRequirement()
		 * @generated
		 */
		EClass ANANOMITY_REQUIREMENT = eINSTANCE.getAnanomityRequirement();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRecordRequirementImpl <em>Data Record Requirement</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.DataRecordRequirementImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDataRecordRequirement()
		 * @generated
		 */
		EClass DATA_RECORD_REQUIREMENT = eINSTANCE.getDataRecordRequirement();

		/**
		 * The meta object literal for the '<em><b>Base Data Store Node</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_RECORD_REQUIREMENT__BASE_DATA_STORE_NODE = eINSTANCE.getDataRecordRequirement_Base_DataStoreNode();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.FunctionalRequirementsImpl <em>Functional Requirements</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.FunctionalRequirementsImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getFunctionalRequirements()
		 * @generated
		 */
		EClass FUNCTIONAL_REQUIREMENTS = eINSTANCE.getFunctionalRequirements();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.NonFunctionalRequirementsImpl <em>Non Functional Requirements</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.NonFunctionalRequirementsImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getNonFunctionalRequirements()
		 * @generated
		 */
		EClass NON_FUNCTIONAL_REQUIREMENTS = eINSTANCE.getNonFunctionalRequirements();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByConsentImpl <em>Lawful By Consent</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByConsentImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByConsent()
		 * @generated
		 */
		EClass LAWFUL_BY_CONSENT = eINSTANCE.getLawfulByConsent();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByContractImpl <em>Lawful By Contract</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByContractImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByContract()
		 * @generated
		 */
		EClass LAWFUL_BY_CONTRACT = eINSTANCE.getLawfulByContract();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByPublicInterestImpl <em>Lawful By Public Interest</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByPublicInterestImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByPublicInterest()
		 * @generated
		 */
		EClass LAWFUL_BY_PUBLIC_INTEREST = eINSTANCE.getLawfulByPublicInterest();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByLegitimateInterestImpl <em>Lawful By Legitimate Interest</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByLegitimateInterestImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByLegitimateInterest()
		 * @generated
		 */
		EClass LAWFUL_BY_LEGITIMATE_INTEREST = eINSTANCE.getLawfulByLegitimateInterest();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByLegalObligationImpl <em>Lawful By Legal Obligation</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByLegalObligationImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByLegalObligation()
		 * @generated
		 */
		EClass LAWFUL_BY_LEGAL_OBLIGATION = eINSTANCE.getLawfulByLegalObligation();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByVitalInterestImpl <em>Lawful By Vital Interest</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfulByVitalInterestImpl
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfulByVitalInterest()
		 * @generated
		 */
		EClass LAWFUL_BY_VITAL_INTEREST = eINSTANCE.getLawfulByVitalInterest();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability <em>Linkability</em>}' enum.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLinkability()
		 * @generated
		 */
		EEnum LINKABILITY = eINSTANCE.getLinkability();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.CollectionMethod <em>Collection Method</em>}' enum.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.CollectionMethod
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getCollectionMethod()
		 * @generated
		 */
		EEnum COLLECTION_METHOD = eINSTANCE.getCollectionMethod();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Duration <em>Duration</em>}' enum.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Duration
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDuration()
		 * @generated
		 */
		EEnum DURATION = eINSTANCE.getDuration();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonymKind <em>Pseudonym Kind</em>}' enum.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonymKind
		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPseudonymKind()
		 * @generated
		 */
		EEnum PSEUDONYM_KIND = eINSTANCE.getPseudonymKind();

	}

} //pdp4engReqGDPRPackage
