/**
 *  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
 *  Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
 *  Patrick Tessier (CEA LIST) Patrick.tessier@cea.fr 
 * 
 */
package org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign;

import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;

/**
 * <!-- begin-user-doc -->
 * The <b>Package</b> for the model.
 * It contains accessors for the meta objects to represent
 * <ul>
 *   <li>each class,</li>
 *   <li>each feature of each class,</li>
 *   <li>each operation of each class,</li>
 *   <li>each enum,</li>
 *   <li>and each data type</li>
 * </ul>
 * <!-- end-user-doc -->
 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignFactory
 * @model kind="package"
 * @generated
 */
public interface pdp4engDesignPackage extends EPackage {
	/**
	 * The package name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNAME = "pdp4engDesign";

	/**
	 * The package namespace URI.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNS_URI = "http://org.eclipse.papyrus.pdp4eng.designer.profile";

	/**
	 * The package namespace name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNS_PREFIX = "pdp4engDesign";

	/**
	 * The singleton instance of the package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	pdp4engDesignPackage eINSTANCE = org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl.init();

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataTypeImpl <em>Data Type</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataTypeImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getDataType()
	 * @generated
	 */
	int DATA_TYPE = 1;

	/**
	 * The feature id for the '<em><b>Base Primitive Type</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_TYPE__BASE_PRIMITIVE_TYPE = 0;

	/**
	 * The number of structural features of the '<em>Data Type</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_TYPE_FEATURE_COUNT = 1;

	/**
	 * The number of operations of the '<em>Data Type</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_TYPE_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.OpaqueDataImpl <em>Opaque Data</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.OpaqueDataImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getOpaqueData()
	 * @generated
	 */
	int OPAQUE_DATA = 0;

	/**
	 * The feature id for the '<em><b>Base Primitive Type</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int OPAQUE_DATA__BASE_PRIMITIVE_TYPE = DATA_TYPE__BASE_PRIMITIVE_TYPE;

	/**
	 * The number of structural features of the '<em>Opaque Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int OPAQUE_DATA_FEATURE_COUNT = DATA_TYPE_FEATURE_COUNT + 0;

	/**
	 * The number of operations of the '<em>Opaque Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int OPAQUE_DATA_OPERATION_COUNT = DATA_TYPE_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.isPersonalDataImpl <em>is Personal Data</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.isPersonalDataImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getisPersonalData()
	 * @generated
	 */
	int IS_PERSONAL_DATA = 2;

	/**
	 * The feature id for the '<em><b>Likelihood</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int IS_PERSONAL_DATA__LIKELIHOOD = 0;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int IS_PERSONAL_DATA__BASE_NAMED_ELEMENT = 1;

	/**
	 * The feature id for the '<em><b>Base Class</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int IS_PERSONAL_DATA__BASE_CLASS = 2;

	/**
	 * The number of structural features of the '<em>is Personal Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int IS_PERSONAL_DATA_FEATURE_COUNT = 3;

	/**
	 * The number of operations of the '<em>is Personal Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int IS_PERSONAL_DATA_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataOutputImpl <em>Data Output</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataOutputImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getDataOutput()
	 * @generated
	 */
	int DATA_OUTPUT = 3;

	/**
	 * The feature id for the '<em><b>Base Output Pin</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_OUTPUT__BASE_OUTPUT_PIN = 0;

	/**
	 * The feature id for the '<em><b>Base Parameter</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_OUTPUT__BASE_PARAMETER = 1;

	/**
	 * The number of structural features of the '<em>Data Output</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_OUTPUT_FEATURE_COUNT = 2;

	/**
	 * The number of operations of the '<em>Data Output</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_OUTPUT_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataImpl <em>Data</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getData()
	 * @generated
	 */
	int DATA = 4;

	/**
	 * The feature id for the '<em><b>Base Class</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA__BASE_CLASS = 0;

	/**
	 * The number of structural features of the '<em>Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_FEATURE_COUNT = 1;

	/**
	 * The number of operations of the '<em>Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataLinkImpl <em>Data Link</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataLinkImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getDataLink()
	 * @generated
	 */
	int DATA_LINK = 5;

	/**
	 * The feature id for the '<em><b>Base Class</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_LINK__BASE_CLASS = DATA__BASE_CLASS;

	/**
	 * The feature id for the '<em><b>Path</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_LINK__PATH = DATA_FEATURE_COUNT + 0;

	/**
	 * The feature id for the '<em><b>Type</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_LINK__TYPE = DATA_FEATURE_COUNT + 1;

	/**
	 * The number of structural features of the '<em>Data Link</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_LINK_FEATURE_COUNT = DATA_FEATURE_COUNT + 2;

	/**
	 * The number of operations of the '<em>Data Link</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_LINK_OPERATION_COUNT = DATA_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CompositeDataImpl <em>Composite Data</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CompositeDataImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getCompositeData()
	 * @generated
	 */
	int COMPOSITE_DATA = 6;

	/**
	 * The feature id for the '<em><b>Base Class</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int COMPOSITE_DATA__BASE_CLASS = DATA__BASE_CLASS;

	/**
	 * The number of structural features of the '<em>Composite Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int COMPOSITE_DATA_FEATURE_COUNT = DATA_FEATURE_COUNT + 0;

	/**
	 * The number of operations of the '<em>Composite Data</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int COMPOSITE_DATA_OPERATION_COUNT = DATA_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.TableImpl <em>Table</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.TableImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getTable()
	 * @generated
	 */
	int TABLE = 7;

	/**
	 * The feature id for the '<em><b>Base Class</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int TABLE__BASE_CLASS = DATA__BASE_CLASS;

	/**
	 * The number of structural features of the '<em>Table</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int TABLE_FEATURE_COUNT = DATA_FEATURE_COUNT + 0;

	/**
	 * The number of operations of the '<em>Table</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int TABLE_OPERATION_COUNT = DATA_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.ExternalEntityImpl <em>External Entity</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.ExternalEntityImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getExternalEntity()
	 * @generated
	 */
	int EXTERNAL_ENTITY = 8;

	/**
	 * The feature id for the '<em><b>Base Activity Parameter Node</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int EXTERNAL_ENTITY__BASE_ACTIVITY_PARAMETER_NODE = 0;

	/**
	 * The feature id for the '<em><b>Entity</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int EXTERNAL_ENTITY__ENTITY = 1;

	/**
	 * The number of structural features of the '<em>External Entity</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int EXTERNAL_ENTITY_FEATURE_COUNT = 2;

	/**
	 * The number of operations of the '<em>External Entity</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int EXTERNAL_ENTITY_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.EntityImpl <em>Entity</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.EntityImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getEntity()
	 * @generated
	 */
	int ENTITY = 9;

	/**
	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int ENTITY__BASE_NAMED_ELEMENT = 0;

	/**
	 * The number of structural features of the '<em>Entity</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int ENTITY_FEATURE_COUNT = 1;

	/**
	 * The number of operations of the '<em>Entity</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int ENTITY_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataStoreImpl <em>Data Store</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataStoreImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getDataStore()
	 * @generated
	 */
	int DATA_STORE = 10;

	/**
	 * The feature id for the '<em><b>Base Data Store Node</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_STORE__BASE_DATA_STORE_NODE = 0;

	/**
	 * The number of structural features of the '<em>Data Store</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_STORE_FEATURE_COUNT = 1;

	/**
	 * The number of operations of the '<em>Data Store</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_STORE_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataInputImpl <em>Data Input</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataInputImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getDataInput()
	 * @generated
	 */
	int DATA_INPUT = 11;

	/**
	 * The feature id for the '<em><b>Base Input Pin</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_INPUT__BASE_INPUT_PIN = 0;

	/**
	 * The feature id for the '<em><b>Base Parameter</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_INPUT__BASE_PARAMETER = 1;

	/**
	 * The number of structural features of the '<em>Data Input</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_INPUT_FEATURE_COUNT = 2;

	/**
	 * The number of operations of the '<em>Data Input</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_INPUT_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.ProcessImpl <em>Process</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.ProcessImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getProcess()
	 * @generated
	 */
	int PROCESS = 12;

	/**
	 * The feature id for the '<em><b>Base Activity</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS__BASE_ACTIVITY = 0;

	/**
	 * The number of structural features of the '<em>Process</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS_FEATURE_COUNT = 1;

	/**
	 * The number of operations of the '<em>Process</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PROCESS_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CallProcessImpl <em>Call Process</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CallProcessImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getCallProcess()
	 * @generated
	 */
	int CALL_PROCESS = 13;

	/**
	 * The feature id for the '<em><b>Base Call Behavior Action</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CALL_PROCESS__BASE_CALL_BEHAVIOR_ACTION = 0;

	/**
	 * The feature id for the '<em><b>Base Opaque Action</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CALL_PROCESS__BASE_OPAQUE_ACTION = 1;

	/**
	 * The number of structural features of the '<em>Call Process</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CALL_PROCESS_FEATURE_COUNT = 2;

	/**
	 * The number of operations of the '<em>Call Process</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CALL_PROCESS_OPERATION_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.SmartGridFrameImpl <em>Smart Grid Frame</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.SmartGridFrameImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getSmartGridFrame()
	 * @generated
	 */
	int SMART_GRID_FRAME = 14;

	/**
	 * The feature id for the '<em><b>Base Class</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SMART_GRID_FRAME__BASE_CLASS = DATA__BASE_CLASS;

	/**
	 * The feature id for the '<em><b>Concentrator ID</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SMART_GRID_FRAME__CONCENTRATOR_ID = DATA_FEATURE_COUNT + 0;

	/**
	 * The feature id for the '<em><b>User Name</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SMART_GRID_FRAME__USER_NAME = DATA_FEATURE_COUNT + 1;

	/**
	 * The feature id for the '<em><b>Postcode</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SMART_GRID_FRAME__POSTCODE = DATA_FEATURE_COUNT + 2;

	/**
	 * The feature id for the '<em><b>Date</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SMART_GRID_FRAME__DATE = DATA_FEATURE_COUNT + 3;

	/**
	 * The feature id for the '<em><b>Consumption</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SMART_GRID_FRAME__CONSUMPTION = DATA_FEATURE_COUNT + 4;

	/**
	 * The feature id for the '<em><b>Crc</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SMART_GRID_FRAME__CRC = DATA_FEATURE_COUNT + 5;

	/**
	 * The feature id for the '<em><b>Id</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SMART_GRID_FRAME__ID = DATA_FEATURE_COUNT + 6;

	/**
	 * The number of structural features of the '<em>Smart Grid Frame</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SMART_GRID_FRAME_FEATURE_COUNT = DATA_FEATURE_COUNT + 7;

	/**
	 * The number of operations of the '<em>Smart Grid Frame</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SMART_GRID_FRAME_OPERATION_COUNT = DATA_OPERATION_COUNT + 0;


	/**
	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl <em>CITS Frame</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getCITSFrame()
	 * @generated
	 */
	int CITS_FRAME = 15;

	/**
	 * The feature id for the '<em><b>Base Class</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__BASE_CLASS = DATA__BASE_CLASS;

	/**
	 * The feature id for the '<em><b>Time</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__TIME = DATA_FEATURE_COUNT + 0;

	/**
	 * The feature id for the '<em><b>Vehicle ID</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__VEHICLE_ID = DATA_FEATURE_COUNT + 1;

	/**
	 * The feature id for the '<em><b>Latitude</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__LATITUDE = DATA_FEATURE_COUNT + 2;

	/**
	 * The feature id for the '<em><b>Longitude</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__LONGITUDE = DATA_FEATURE_COUNT + 3;

	/**
	 * The feature id for the '<em><b>Speed Value</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__SPEED_VALUE = DATA_FEATURE_COUNT + 4;

	/**
	 * The feature id for the '<em><b>Heading Value</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__HEADING_VALUE = DATA_FEATURE_COUNT + 5;

	/**
	 * The feature id for the '<em><b>Brake Pedal Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__BRAKE_PEDAL_ENGAGED = DATA_FEATURE_COUNT + 6;

	/**
	 * The feature id for the '<em><b>Gas Pedal Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__GAS_PEDAL_ENGAGED = DATA_FEATURE_COUNT + 7;

	/**
	 * The feature id for the '<em><b>Emergency Brake Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__EMERGENCY_BRAKE_ENGAGED = DATA_FEATURE_COUNT + 8;

	/**
	 * The feature id for the '<em><b>Collision Warning Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__COLLISION_WARNING_ENGAGED = DATA_FEATURE_COUNT + 9;

	/**
	 * The feature id for the '<em><b>Acc Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__ACC_ENGAGED = DATA_FEATURE_COUNT + 10;

	/**
	 * The feature id for the '<em><b>Cruise Control Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__CRUISE_CONTROL_ENGAGED = DATA_FEATURE_COUNT + 11;

	/**
	 * The feature id for the '<em><b>Speed Limiter Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__SPEED_LIMITER_ENGAGED = DATA_FEATURE_COUNT + 12;

	/**
	 * The feature id for the '<em><b>Certificate ID</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME__CERTIFICATE_ID = DATA_FEATURE_COUNT + 13;

	/**
	 * The number of structural features of the '<em>CITS Frame</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME_FEATURE_COUNT = DATA_FEATURE_COUNT + 14;

	/**
	 * The number of operations of the '<em>CITS Frame</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CITS_FRAME_OPERATION_COUNT = DATA_OPERATION_COUNT + 0;


	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.OpaqueData <em>Opaque Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Opaque Data</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.OpaqueData
	 * @generated
	 */
	EClass getOpaqueData();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataType <em>Data Type</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Data Type</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataType
	 * @generated
	 */
	EClass getDataType();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataType#getBase_PrimitiveType <em>Base Primitive Type</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Primitive Type</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataType#getBase_PrimitiveType()
	 * @see #getDataType()
	 * @generated
	 */
	EReference getDataType_Base_PrimitiveType();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.isPersonalData <em>is Personal Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>is Personal Data</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.isPersonalData
	 * @generated
	 */
	EClass getisPersonalData();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.isPersonalData#getLikelihood <em>Likelihood</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Likelihood</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.isPersonalData#getLikelihood()
	 * @see #getisPersonalData()
	 * @generated
	 */
	EAttribute getisPersonalData_Likelihood();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.isPersonalData#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.designer.profile.pdp4engDesign.isPersonalData#getBase_NamedElement()
	 * @see #getisPersonalData()
	 * @generated
	 */
	EReference getisPersonalData_Base_NamedElement();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.isPersonalData#getBase_Class <em>Base Class</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Class</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.isPersonalData#getBase_Class()
	 * @see #getisPersonalData()
	 * @generated
	 */
	EReference getisPersonalData_Base_Class();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataOutput <em>Data Output</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Data Output</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataOutput
	 * @generated
	 */
	EClass getDataOutput();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataOutput#getBase_OutputPin <em>Base Output Pin</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Output Pin</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataOutput#getBase_OutputPin()
	 * @see #getDataOutput()
	 * @generated
	 */
	EReference getDataOutput_Base_OutputPin();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataOutput#getBase_Parameter <em>Base Parameter</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Parameter</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataOutput#getBase_Parameter()
	 * @see #getDataOutput()
	 * @generated
	 */
	EReference getDataOutput_Base_Parameter();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Data <em>Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Data</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Data
	 * @generated
	 */
	EClass getData();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Data#getBase_Class <em>Base Class</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Class</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Data#getBase_Class()
	 * @see #getData()
	 * @generated
	 */
	EReference getData_Base_Class();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataLink <em>Data Link</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Data Link</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataLink
	 * @generated
	 */
	EClass getDataLink();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataLink#getPath <em>Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Path</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataLink#getPath()
	 * @see #getDataLink()
	 * @generated
	 */
	EAttribute getDataLink_Path();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataLink#getType <em>Type</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Type</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataLink#getType()
	 * @see #getDataLink()
	 * @generated
	 */
	EReference getDataLink_Type();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CompositeData <em>Composite Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Composite Data</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CompositeData
	 * @generated
	 */
	EClass getCompositeData();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Table <em>Table</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Table</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Table
	 * @generated
	 */
	EClass getTable();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.ExternalEntity <em>External Entity</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>External Entity</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.ExternalEntity
	 * @generated
	 */
	EClass getExternalEntity();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.ExternalEntity#getBase_ActivityParameterNode <em>Base Activity Parameter Node</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Activity Parameter Node</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.ExternalEntity#getBase_ActivityParameterNode()
	 * @see #getExternalEntity()
	 * @generated
	 */
	EReference getExternalEntity_Base_ActivityParameterNode();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.ExternalEntity#getEntity <em>Entity</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Entity</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.ExternalEntity#getEntity()
	 * @see #getExternalEntity()
	 * @generated
	 */
	EReference getExternalEntity_Entity();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Entity <em>Entity</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Entity</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Entity
	 * @generated
	 */
	EClass getEntity();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Entity#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.designer.profile.pdp4engDesign.Entity#getBase_NamedElement()
	 * @see #getEntity()
	 * @generated
	 */
	EReference getEntity_Base_NamedElement();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataStore <em>Data Store</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Data Store</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataStore
	 * @generated
	 */
	EClass getDataStore();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataStore#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.designer.profile.pdp4engDesign.DataStore#getBase_DataStoreNode()
	 * @see #getDataStore()
	 * @generated
	 */
	EReference getDataStore_Base_DataStoreNode();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataInput <em>Data Input</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Data Input</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataInput
	 * @generated
	 */
	EClass getDataInput();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataInput#getBase_InputPin <em>Base Input Pin</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Input Pin</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataInput#getBase_InputPin()
	 * @see #getDataInput()
	 * @generated
	 */
	EReference getDataInput_Base_InputPin();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataInput#getBase_Parameter <em>Base Parameter</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Parameter</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.DataInput#getBase_Parameter()
	 * @see #getDataInput()
	 * @generated
	 */
	EReference getDataInput_Base_Parameter();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Process <em>Process</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Process</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Process
	 * @generated
	 */
	EClass getProcess();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Process#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.designer.profile.pdp4engDesign.Process#getBase_Activity()
	 * @see #getProcess()
	 * @generated
	 */
	EReference getProcess_Base_Activity();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess <em>Call Process</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Call Process</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess
	 * @generated
	 */
	EClass getCallProcess();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess#getBase_CallBehaviorAction <em>Base Call Behavior Action</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Call Behavior Action</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess#getBase_CallBehaviorAction()
	 * @see #getCallProcess()
	 * @generated
	 */
	EReference getCallProcess_Base_CallBehaviorAction();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess#getBase_OpaqueAction <em>Base Opaque Action</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Base Opaque Action</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess#getBase_OpaqueAction()
	 * @see #getCallProcess()
	 * @generated
	 */
	EReference getCallProcess_Base_OpaqueAction();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame <em>Smart Grid Frame</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Smart Grid Frame</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame
	 * @generated
	 */
	EClass getSmartGridFrame();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getConcentratorID <em>Concentrator ID</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Concentrator ID</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getConcentratorID()
	 * @see #getSmartGridFrame()
	 * @generated
	 */
	EAttribute getSmartGridFrame_ConcentratorID();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getUserName <em>User Name</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>User Name</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getUserName()
	 * @see #getSmartGridFrame()
	 * @generated
	 */
	EAttribute getSmartGridFrame_UserName();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getPostcode <em>Postcode</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Postcode</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getPostcode()
	 * @see #getSmartGridFrame()
	 * @generated
	 */
	EAttribute getSmartGridFrame_Postcode();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getDate <em>Date</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Date</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getDate()
	 * @see #getSmartGridFrame()
	 * @generated
	 */
	EAttribute getSmartGridFrame_Date();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getConsumption <em>Consumption</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Consumption</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getConsumption()
	 * @see #getSmartGridFrame()
	 * @generated
	 */
	EAttribute getSmartGridFrame_Consumption();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getCrc <em>Crc</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Crc</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getCrc()
	 * @see #getSmartGridFrame()
	 * @generated
	 */
	EAttribute getSmartGridFrame_Crc();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getId <em>Id</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Id</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.SmartGridFrame#getId()
	 * @see #getSmartGridFrame()
	 * @generated
	 */
	EAttribute getSmartGridFrame_Id();

	/**
	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame <em>CITS Frame</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>CITS Frame</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame
	 * @generated
	 */
	EClass getCITSFrame();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getTime <em>Time</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Time</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getTime()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_Time();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getVehicleID <em>Vehicle ID</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Vehicle ID</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getVehicleID()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_VehicleID();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLatitude <em>Latitude</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Latitude</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLatitude()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_Latitude();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLongitude <em>Longitude</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Longitude</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLongitude()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_Longitude();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getSpeedValue <em>Speed Value</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Speed Value</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getSpeedValue()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_SpeedValue();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getHeadingValue <em>Heading Value</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Heading Value</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getHeadingValue()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_HeadingValue();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isBrakePedalEngaged <em>Brake Pedal Engaged</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Brake Pedal Engaged</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isBrakePedalEngaged()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_BrakePedalEngaged();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isGasPedalEngaged <em>Gas Pedal Engaged</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Gas Pedal Engaged</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isGasPedalEngaged()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_GasPedalEngaged();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isEmergencyBrakeEngaged <em>Emergency Brake Engaged</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Emergency Brake Engaged</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isEmergencyBrakeEngaged()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_EmergencyBrakeEngaged();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCollisionWarningEngaged <em>Collision Warning Engaged</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Collision Warning Engaged</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCollisionWarningEngaged()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_CollisionWarningEngaged();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isAccEngaged <em>Acc Engaged</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Acc Engaged</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isAccEngaged()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_AccEngaged();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCruiseControlEngaged <em>Cruise Control Engaged</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Cruise Control Engaged</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCruiseControlEngaged()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_CruiseControlEngaged();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isSpeedLimiterEngaged <em>Speed Limiter Engaged</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Speed Limiter Engaged</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isSpeedLimiterEngaged()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_SpeedLimiterEngaged();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getCertificateID <em>Certificate ID</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Certificate ID</em>'.
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getCertificateID()
	 * @see #getCITSFrame()
	 * @generated
	 */
	EAttribute getCITSFrame_CertificateID();

	/**
	 * 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
	 */
	pdp4engDesignFactory getpdp4engDesignFactory();

	/**
	 * <!-- 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.designer.profile.pdp4engDesign.impl.OpaqueDataImpl <em>Opaque Data</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.OpaqueDataImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getOpaqueData()
		 * @generated
		 */
		EClass OPAQUE_DATA = eINSTANCE.getOpaqueData();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataTypeImpl <em>Data Type</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataTypeImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getDataType()
		 * @generated
		 */
		EClass DATA_TYPE = eINSTANCE.getDataType();

		/**
		 * The meta object literal for the '<em><b>Base Primitive Type</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_TYPE__BASE_PRIMITIVE_TYPE = eINSTANCE.getDataType_Base_PrimitiveType();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.isPersonalDataImpl <em>is Personal Data</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.isPersonalDataImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getisPersonalData()
		 * @generated
		 */
		EClass IS_PERSONAL_DATA = eINSTANCE.getisPersonalData();

		/**
		 * The meta object literal for the '<em><b>Likelihood</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute IS_PERSONAL_DATA__LIKELIHOOD = eINSTANCE.getisPersonalData_Likelihood();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference IS_PERSONAL_DATA__BASE_NAMED_ELEMENT = eINSTANCE.getisPersonalData_Base_NamedElement();

		/**
		 * The meta object literal for the '<em><b>Base Class</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference IS_PERSONAL_DATA__BASE_CLASS = eINSTANCE.getisPersonalData_Base_Class();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataOutputImpl <em>Data Output</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataOutputImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getDataOutput()
		 * @generated
		 */
		EClass DATA_OUTPUT = eINSTANCE.getDataOutput();

		/**
		 * The meta object literal for the '<em><b>Base Output Pin</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_OUTPUT__BASE_OUTPUT_PIN = eINSTANCE.getDataOutput_Base_OutputPin();

		/**
		 * The meta object literal for the '<em><b>Base Parameter</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_OUTPUT__BASE_PARAMETER = eINSTANCE.getDataOutput_Base_Parameter();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataImpl <em>Data</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getData()
		 * @generated
		 */
		EClass DATA = eINSTANCE.getData();

		/**
		 * The meta object literal for the '<em><b>Base Class</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA__BASE_CLASS = eINSTANCE.getData_Base_Class();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataLinkImpl <em>Data Link</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataLinkImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getDataLink()
		 * @generated
		 */
		EClass DATA_LINK = eINSTANCE.getDataLink();

		/**
		 * The meta object literal for the '<em><b>Path</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute DATA_LINK__PATH = eINSTANCE.getDataLink_Path();

		/**
		 * The meta object literal for the '<em><b>Type</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_LINK__TYPE = eINSTANCE.getDataLink_Type();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CompositeDataImpl <em>Composite Data</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CompositeDataImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getCompositeData()
		 * @generated
		 */
		EClass COMPOSITE_DATA = eINSTANCE.getCompositeData();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.TableImpl <em>Table</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.TableImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getTable()
		 * @generated
		 */
		EClass TABLE = eINSTANCE.getTable();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.ExternalEntityImpl <em>External Entity</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.ExternalEntityImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getExternalEntity()
		 * @generated
		 */
		EClass EXTERNAL_ENTITY = eINSTANCE.getExternalEntity();

		/**
		 * The meta object literal for the '<em><b>Base Activity Parameter Node</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference EXTERNAL_ENTITY__BASE_ACTIVITY_PARAMETER_NODE = eINSTANCE.getExternalEntity_Base_ActivityParameterNode();

		/**
		 * The meta object literal for the '<em><b>Entity</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference EXTERNAL_ENTITY__ENTITY = eINSTANCE.getExternalEntity_Entity();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.EntityImpl <em>Entity</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.EntityImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getEntity()
		 * @generated
		 */
		EClass ENTITY = eINSTANCE.getEntity();

		/**
		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference ENTITY__BASE_NAMED_ELEMENT = eINSTANCE.getEntity_Base_NamedElement();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataStoreImpl <em>Data Store</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataStoreImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getDataStore()
		 * @generated
		 */
		EClass DATA_STORE = eINSTANCE.getDataStore();

		/**
		 * 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_STORE__BASE_DATA_STORE_NODE = eINSTANCE.getDataStore_Base_DataStoreNode();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataInputImpl <em>Data Input</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.DataInputImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getDataInput()
		 * @generated
		 */
		EClass DATA_INPUT = eINSTANCE.getDataInput();

		/**
		 * The meta object literal for the '<em><b>Base Input Pin</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_INPUT__BASE_INPUT_PIN = eINSTANCE.getDataInput_Base_InputPin();

		/**
		 * The meta object literal for the '<em><b>Base Parameter</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference DATA_INPUT__BASE_PARAMETER = eINSTANCE.getDataInput_Base_Parameter();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.ProcessImpl <em>Process</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.ProcessImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getProcess()
		 * @generated
		 */
		EClass PROCESS = eINSTANCE.getProcess();

		/**
		 * The meta object literal for the '<em><b>Base Activity</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PROCESS__BASE_ACTIVITY = eINSTANCE.getProcess_Base_Activity();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CallProcessImpl <em>Call Process</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CallProcessImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getCallProcess()
		 * @generated
		 */
		EClass CALL_PROCESS = eINSTANCE.getCallProcess();

		/**
		 * The meta object literal for the '<em><b>Base Call Behavior Action</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CALL_PROCESS__BASE_CALL_BEHAVIOR_ACTION = eINSTANCE.getCallProcess_Base_CallBehaviorAction();

		/**
		 * The meta object literal for the '<em><b>Base Opaque Action</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CALL_PROCESS__BASE_OPAQUE_ACTION = eINSTANCE.getCallProcess_Base_OpaqueAction();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.SmartGridFrameImpl <em>Smart Grid Frame</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.SmartGridFrameImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getSmartGridFrame()
		 * @generated
		 */
		EClass SMART_GRID_FRAME = eINSTANCE.getSmartGridFrame();

		/**
		 * The meta object literal for the '<em><b>Concentrator ID</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute SMART_GRID_FRAME__CONCENTRATOR_ID = eINSTANCE.getSmartGridFrame_ConcentratorID();

		/**
		 * The meta object literal for the '<em><b>User Name</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute SMART_GRID_FRAME__USER_NAME = eINSTANCE.getSmartGridFrame_UserName();

		/**
		 * The meta object literal for the '<em><b>Postcode</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute SMART_GRID_FRAME__POSTCODE = eINSTANCE.getSmartGridFrame_Postcode();

		/**
		 * The meta object literal for the '<em><b>Date</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute SMART_GRID_FRAME__DATE = eINSTANCE.getSmartGridFrame_Date();

		/**
		 * The meta object literal for the '<em><b>Consumption</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute SMART_GRID_FRAME__CONSUMPTION = eINSTANCE.getSmartGridFrame_Consumption();

		/**
		 * The meta object literal for the '<em><b>Crc</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute SMART_GRID_FRAME__CRC = eINSTANCE.getSmartGridFrame_Crc();

		/**
		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute SMART_GRID_FRAME__ID = eINSTANCE.getSmartGridFrame_Id();

		/**
		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl <em>CITS Frame</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl
		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getCITSFrame()
		 * @generated
		 */
		EClass CITS_FRAME = eINSTANCE.getCITSFrame();

		/**
		 * The meta object literal for the '<em><b>Time</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__TIME = eINSTANCE.getCITSFrame_Time();

		/**
		 * The meta object literal for the '<em><b>Vehicle ID</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__VEHICLE_ID = eINSTANCE.getCITSFrame_VehicleID();

		/**
		 * The meta object literal for the '<em><b>Latitude</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__LATITUDE = eINSTANCE.getCITSFrame_Latitude();

		/**
		 * The meta object literal for the '<em><b>Longitude</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__LONGITUDE = eINSTANCE.getCITSFrame_Longitude();

		/**
		 * The meta object literal for the '<em><b>Speed Value</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__SPEED_VALUE = eINSTANCE.getCITSFrame_SpeedValue();

		/**
		 * The meta object literal for the '<em><b>Heading Value</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__HEADING_VALUE = eINSTANCE.getCITSFrame_HeadingValue();

		/**
		 * The meta object literal for the '<em><b>Brake Pedal Engaged</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__BRAKE_PEDAL_ENGAGED = eINSTANCE.getCITSFrame_BrakePedalEngaged();

		/**
		 * The meta object literal for the '<em><b>Gas Pedal Engaged</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__GAS_PEDAL_ENGAGED = eINSTANCE.getCITSFrame_GasPedalEngaged();

		/**
		 * The meta object literal for the '<em><b>Emergency Brake Engaged</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__EMERGENCY_BRAKE_ENGAGED = eINSTANCE.getCITSFrame_EmergencyBrakeEngaged();

		/**
		 * The meta object literal for the '<em><b>Collision Warning Engaged</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__COLLISION_WARNING_ENGAGED = eINSTANCE.getCITSFrame_CollisionWarningEngaged();

		/**
		 * The meta object literal for the '<em><b>Acc Engaged</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__ACC_ENGAGED = eINSTANCE.getCITSFrame_AccEngaged();

		/**
		 * The meta object literal for the '<em><b>Cruise Control Engaged</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__CRUISE_CONTROL_ENGAGED = eINSTANCE.getCITSFrame_CruiseControlEngaged();

		/**
		 * The meta object literal for the '<em><b>Speed Limiter Engaged</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__SPEED_LIMITER_ENGAGED = eINSTANCE.getCITSFrame_SpeedLimiterEngaged();

		/**
		 * The meta object literal for the '<em><b>Certificate ID</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CITS_FRAME__CERTIFICATE_ID = eINSTANCE.getCITSFrame_CertificateID();

	}

} //pdp4engDesignPackage
