/**
 * Copyright (c) 2011, 2018 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License v1.0
 *  which accompanies this distribution, and is available at
 *  http://www.eclipse.org/legal/epl-v10.html
 *  
 *  Contributors:                                                      
 *     Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 *  
 *  generated from SignalDSL.xcore
 * 
 *  
 */
package org.eclipse.osbp.xtext.signal;

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

import org.eclipse.osbp.dsl.semantic.common.types.OSBPTypesPackage;

/**
 * <!-- 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.osbp.xtext.signal.SignalDSLFactory
 * @model kind="package"
 *        annotation="http://www.eclipse.org/emf/2002/GenModel fileExtensions='signal' modelName='SignalDSL' prefix='SignalDSL' loadInitialization='false' literalsInterface='true' copyrightText='Copyright (c) 2011, 2018 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)\r\n All rights reserved. This program and the accompanying materials\r\n are made available under the terms of the Eclipse Public License v1.0\r\n which accompanies this distribution, and is available at\r\n http://www.eclipse.org/legal/epl-v10.html\r\n \r\n Contributors:                                                      \r\n    Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation\r\n \r\n generated from SignalDSL.xcore\r\n\r\n ' updateClasspath='false' basePackage='org.eclipse.osbp.xtext'"
 *        annotation="http://www.eclipse.org/emf/2002/Ecore rootPackage='signaldsl'"
 * @generated
 */
public interface SignalDSLPackage extends EPackage {
	/**
	 * The package name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNAME = "signal";

	/**
	 * The package namespace URI.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNS_URI = "http://osbp.eclipse.org/xtext/signal/SignalDSL";

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

	/**
	 * The singleton instance of the package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	SignalDSLPackage eINSTANCE = org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl.init();

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalModelImpl <em>Signal Model</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalModelImpl
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalModel()
	 * @generated
	 */
	int SIGNAL_MODEL = 0;

	/**
	 * The feature id for the '<em><b>Import Section</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_MODEL__IMPORT_SECTION = 0;

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalLazyResolverImpl <em>Signal Lazy Resolver</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalLazyResolverImpl
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalLazyResolver()
	 * @generated
	 */
	int SIGNAL_LAZY_RESOLVER = 1;

	/**
	 * The number of structural features of the '<em>Signal Lazy Resolver</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_LAZY_RESOLVER_FEATURE_COUNT = 0;

	/**
	 * The operation id for the '<em>EResolve Proxy</em>' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_LAZY_RESOLVER___ERESOLVE_PROXY__INTERNALEOBJECT = 0;

	/**
	 * The number of operations of the '<em>Signal Lazy Resolver</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_LAZY_RESOLVER_OPERATION_COUNT = 1;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalPackageImpl <em>Signal Package</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalPackageImpl
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalPackage()
	 * @generated
	 */
	int SIGNAL_PACKAGE = 2;

	/**
	 * The feature id for the '<em><b>Name</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_PACKAGE__NAME = OSBPTypesPackage.LPACKAGE__NAME;

	/**
	 * The feature id for the '<em><b>Watchers</b></em>' containment reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_PACKAGE__WATCHERS = OSBPTypesPackage.LPACKAGE_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Signal Package</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_PACKAGE_FEATURE_COUNT = OSBPTypesPackage.LPACKAGE_FEATURE_COUNT + 1;

	/**
	 * The operation id for the '<em>EResolve Proxy</em>' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_PACKAGE___ERESOLVE_PROXY__INTERNALEOBJECT = OSBPTypesPackage.LPACKAGE___ERESOLVE_PROXY__INTERNALEOBJECT;

	/**
	 * The number of operations of the '<em>Signal Package</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_PACKAGE_OPERATION_COUNT = OSBPTypesPackage.LPACKAGE_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalBaseImpl <em>Signal Base</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalBaseImpl
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalBase()
	 * @generated
	 */
	int SIGNAL_BASE = 3;

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

	/**
	 * The number of structural features of the '<em>Signal Base</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_BASE_FEATURE_COUNT = SIGNAL_LAZY_RESOLVER_FEATURE_COUNT + 1;

	/**
	 * The operation id for the '<em>EResolve Proxy</em>' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_BASE___ERESOLVE_PROXY__INTERNALEOBJECT = SIGNAL_LAZY_RESOLVER___ERESOLVE_PROXY__INTERNALEOBJECT;

	/**
	 * The number of operations of the '<em>Signal Base</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_BASE_OPERATION_COUNT = SIGNAL_LAZY_RESOLVER_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalWatcherImpl <em>Signal Watcher</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalWatcherImpl
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalWatcher()
	 * @generated
	 */
	int SIGNAL_WATCHER = 4;

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

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

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

	/**
	 * The feature id for the '<em><b>Handlers</b></em>' containment reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_WATCHER__HANDLERS = SIGNAL_LAZY_RESOLVER_FEATURE_COUNT + 3;

	/**
	 * The number of structural features of the '<em>Signal Watcher</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_WATCHER_FEATURE_COUNT = SIGNAL_LAZY_RESOLVER_FEATURE_COUNT + 4;

	/**
	 * The operation id for the '<em>EResolve Proxy</em>' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_WATCHER___ERESOLVE_PROXY__INTERNALEOBJECT = SIGNAL_LAZY_RESOLVER___ERESOLVE_PROXY__INTERNALEOBJECT;

	/**
	 * The number of operations of the '<em>Signal Watcher</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_WATCHER_OPERATION_COUNT = SIGNAL_LAZY_RESOLVER_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalHandlerImpl <em>Signal Handler</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalHandlerImpl
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalHandler()
	 * @generated
	 */
	int SIGNAL_HANDLER = 5;

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

	/**
	 * The feature id for the '<em><b>Action Type</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_HANDLER__ACTION_TYPE = SIGNAL_LAZY_RESOLVER_FEATURE_COUNT + 1;

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

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

	/**
	 * The feature id for the '<em><b>Executiontype</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_HANDLER__EXECUTIONTYPE = SIGNAL_LAZY_RESOLVER_FEATURE_COUNT + 4;

	/**
	 * The number of structural features of the '<em>Signal Handler</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_HANDLER_FEATURE_COUNT = SIGNAL_LAZY_RESOLVER_FEATURE_COUNT + 5;

	/**
	 * The operation id for the '<em>EResolve Proxy</em>' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_HANDLER___ERESOLVE_PROXY__INTERNALEOBJECT = SIGNAL_LAZY_RESOLVER___ERESOLVE_PROXY__INTERNALEOBJECT;

	/**
	 * The number of operations of the '<em>Signal Handler</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_HANDLER_OPERATION_COUNT = SIGNAL_LAZY_RESOLVER_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.SignalProcessor <em>Signal Processor</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.SignalProcessor
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalProcessor()
	 * @generated
	 */
	int SIGNAL_PROCESSOR = 6;

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

	/**
	 * The operation id for the '<em>EResolve Proxy</em>' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_PROCESSOR___ERESOLVE_PROXY__INTERNALEOBJECT = SIGNAL_LAZY_RESOLVER___ERESOLVE_PROXY__INTERNALEOBJECT;

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

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalDatainterchangeImpl <em>Signal Datainterchange</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDatainterchangeImpl
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalDatainterchange()
	 * @generated
	 */
	int SIGNAL_DATAINTERCHANGE = 7;

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

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

	/**
	 * The feature id for the '<em><b>File Name</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_DATAINTERCHANGE__FILE_NAME = SIGNAL_PROCESSOR_FEATURE_COUNT + 2;

	/**
	 * The number of structural features of the '<em>Signal Datainterchange</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_DATAINTERCHANGE_FEATURE_COUNT = SIGNAL_PROCESSOR_FEATURE_COUNT + 3;

	/**
	 * The operation id for the '<em>EResolve Proxy</em>' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_DATAINTERCHANGE___ERESOLVE_PROXY__INTERNALEOBJECT = SIGNAL_PROCESSOR___ERESOLVE_PROXY__INTERNALEOBJECT;

	/**
	 * The number of operations of the '<em>Signal Datainterchange</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SIGNAL_DATAINTERCHANGE_OPERATION_COUNT = SIGNAL_PROCESSOR_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.impl.DataTransferImpl <em>Data Transfer</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.impl.DataTransferImpl
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getDataTransfer()
	 * @generated
	 */
	int DATA_TRANSFER = 8;

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

	/**
	 * The operation id for the '<em>EResolve Proxy</em>' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int DATA_TRANSFER___ERESOLVE_PROXY__INTERNALEOBJECT = SIGNAL_LAZY_RESOLVER___ERESOLVE_PROXY__INTERNALEOBJECT;

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

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.impl.SingleTransferImpl <em>Single Transfer</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.impl.SingleTransferImpl
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSingleTransfer()
	 * @generated
	 */
	int SINGLE_TRANSFER = 9;

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

	/**
	 * The number of structural features of the '<em>Single Transfer</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SINGLE_TRANSFER_FEATURE_COUNT = DATA_TRANSFER_FEATURE_COUNT + 1;

	/**
	 * The operation id for the '<em>EResolve Proxy</em>' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SINGLE_TRANSFER___ERESOLVE_PROXY__INTERNALEOBJECT = DATA_TRANSFER___ERESOLVE_PROXY__INTERNALEOBJECT;

	/**
	 * The number of operations of the '<em>Single Transfer</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int SINGLE_TRANSFER_OPERATION_COUNT = DATA_TRANSFER_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.impl.ListTransferImpl <em>List Transfer</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.impl.ListTransferImpl
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getListTransfer()
	 * @generated
	 */
	int LIST_TRANSFER = 10;

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

	/**
	 * The number of structural features of the '<em>List Transfer</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LIST_TRANSFER_FEATURE_COUNT = DATA_TRANSFER_FEATURE_COUNT + 1;

	/**
	 * The operation id for the '<em>EResolve Proxy</em>' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LIST_TRANSFER___ERESOLVE_PROXY__INTERNALEOBJECT = DATA_TRANSFER___ERESOLVE_PROXY__INTERNALEOBJECT;

	/**
	 * The number of operations of the '<em>List Transfer</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int LIST_TRANSFER_OPERATION_COUNT = DATA_TRANSFER_OPERATION_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.SignalHandlerTypeEnum <em>Signal Handler Type Enum</em>}' enum.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.SignalHandlerTypeEnum
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalHandlerTypeEnum()
	 * @generated
	 */
	int SIGNAL_HANDLER_TYPE_ENUM = 11;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.SignalTypeEnum <em>Signal Type Enum</em>}' enum.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.SignalTypeEnum
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalTypeEnum()
	 * @generated
	 */
	int SIGNAL_TYPE_ENUM = 12;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.SignalActionEnum <em>Signal Action Enum</em>}' enum.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.SignalActionEnum
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalActionEnum()
	 * @generated
	 */
	int SIGNAL_ACTION_ENUM = 13;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.xtext.signal.SignalExecutionTypeEnum <em>Signal Execution Type Enum</em>}' enum.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.xtext.signal.SignalExecutionTypeEnum
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalExecutionTypeEnum()
	 * @generated
	 */
	int SIGNAL_EXECUTION_TYPE_ENUM = 14;

	/**
	 * The meta object id for the '<em>Internal EObject</em>' data type.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.emf.ecore.InternalEObject
	 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getInternalEObject()
	 * @generated
	 */
	int INTERNAL_EOBJECT = 15;


	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.SignalModel <em>Signal Model</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Signal Model</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalModel
	 * @generated
	 */
	EClass getSignalModel();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.xtext.signal.SignalModel#getImportSection <em>Import Section</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Import Section</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalModel#getImportSection()
	 * @see #getSignalModel()
	 * @generated
	 */
	EReference getSignalModel_ImportSection();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.xtext.signal.SignalModel#getPackages <em>Packages</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference list '<em>Packages</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalModel#getPackages()
	 * @see #getSignalModel()
	 * @generated
	 */
	EReference getSignalModel_Packages();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.SignalLazyResolver <em>Signal Lazy Resolver</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Signal Lazy Resolver</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalLazyResolver
	 * @generated
	 */
	EClass getSignalLazyResolver();

	/**
	 * Returns the meta object for the '{@link org.eclipse.osbp.xtext.signal.SignalLazyResolver#eResolveProxy(org.eclipse.emf.ecore.InternalEObject) <em>EResolve Proxy</em>}' operation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the '<em>EResolve Proxy</em>' operation.
	 * @see org.eclipse.osbp.xtext.signal.SignalLazyResolver#eResolveProxy(org.eclipse.emf.ecore.InternalEObject)
	 * @generated
	 */
	EOperation getSignalLazyResolver__EResolveProxy__InternalEObject();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.SignalPackage <em>Signal Package</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Signal Package</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalPackage
	 * @generated
	 */
	EClass getSignalPackage();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.xtext.signal.SignalPackage#getWatchers <em>Watchers</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference list '<em>Watchers</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalPackage#getWatchers()
	 * @see #getSignalPackage()
	 * @generated
	 */
	EReference getSignalPackage_Watchers();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.SignalBase <em>Signal Base</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Signal Base</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalBase
	 * @generated
	 */
	EClass getSignalBase();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.signal.SignalBase#getName <em>Name</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Name</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalBase#getName()
	 * @see #getSignalBase()
	 * @generated
	 */
	EAttribute getSignalBase_Name();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.SignalWatcher <em>Signal Watcher</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Signal Watcher</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalWatcher
	 * @generated
	 */
	EClass getSignalWatcher();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.signal.SignalWatcher#getName <em>Name</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Name</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalWatcher#getName()
	 * @see #getSignalWatcher()
	 * @generated
	 */
	EAttribute getSignalWatcher_Name();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.signal.SignalWatcher#getDirectory <em>Directory</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Directory</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalWatcher#getDirectory()
	 * @see #getSignalWatcher()
	 * @generated
	 */
	EAttribute getSignalWatcher_Directory();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.signal.SignalWatcher#getSignal <em>Signal</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Signal</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalWatcher#getSignal()
	 * @see #getSignalWatcher()
	 * @generated
	 */
	EAttribute getSignalWatcher_Signal();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.xtext.signal.SignalWatcher#getHandlers <em>Handlers</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference list '<em>Handlers</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalWatcher#getHandlers()
	 * @see #getSignalWatcher()
	 * @generated
	 */
	EReference getSignalWatcher_Handlers();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.SignalHandler <em>Signal Handler</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Signal Handler</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalHandler
	 * @generated
	 */
	EClass getSignalHandler();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.signal.SignalHandler#getName <em>Name</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Name</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalHandler#getName()
	 * @see #getSignalHandler()
	 * @generated
	 */
	EAttribute getSignalHandler_Name();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.signal.SignalHandler#getActionType <em>Action Type</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Action Type</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalHandler#getActionType()
	 * @see #getSignalHandler()
	 * @generated
	 */
	EAttribute getSignalHandler_ActionType();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.signal.SignalHandler#getFilemask <em>Filemask</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Filemask</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalHandler#getFilemask()
	 * @see #getSignalHandler()
	 * @generated
	 */
	EAttribute getSignalHandler_Filemask();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.xtext.signal.SignalHandler#getData <em>Data</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Data</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalHandler#getData()
	 * @see #getSignalHandler()
	 * @generated
	 */
	EReference getSignalHandler_Data();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.signal.SignalHandler#getExecutiontype <em>Executiontype</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Executiontype</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalHandler#getExecutiontype()
	 * @see #getSignalHandler()
	 * @generated
	 */
	EAttribute getSignalHandler_Executiontype();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.SignalProcessor <em>Signal Processor</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Signal Processor</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalProcessor
	 * @generated
	 */
	EClass getSignalProcessor();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.SignalDatainterchange <em>Signal Datainterchange</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Signal Datainterchange</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalDatainterchange
	 * @generated
	 */
	EClass getSignalDatainterchange();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.signal.SignalDatainterchange#getDataAction <em>Data Action</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Data Action</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalDatainterchange#getDataAction()
	 * @see #getSignalDatainterchange()
	 * @generated
	 */
	EAttribute getSignalDatainterchange_DataAction();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.osbp.xtext.signal.SignalDatainterchange#getDataRef <em>Data Ref</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Data Ref</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalDatainterchange#getDataRef()
	 * @see #getSignalDatainterchange()
	 * @generated
	 */
	EReference getSignalDatainterchange_DataRef();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.signal.SignalDatainterchange#getFileName <em>File Name</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>File Name</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalDatainterchange#getFileName()
	 * @see #getSignalDatainterchange()
	 * @generated
	 */
	EAttribute getSignalDatainterchange_FileName();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.DataTransfer <em>Data Transfer</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Data Transfer</em>'.
	 * @see org.eclipse.osbp.xtext.signal.DataTransfer
	 * @generated
	 */
	EClass getDataTransfer();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.SingleTransfer <em>Single Transfer</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Single Transfer</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SingleTransfer
	 * @generated
	 */
	EClass getSingleTransfer();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.xtext.signal.SingleTransfer#getInterchange <em>Interchange</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Interchange</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SingleTransfer#getInterchange()
	 * @see #getSingleTransfer()
	 * @generated
	 */
	EReference getSingleTransfer_Interchange();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.signal.ListTransfer <em>List Transfer</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>List Transfer</em>'.
	 * @see org.eclipse.osbp.xtext.signal.ListTransfer
	 * @generated
	 */
	EClass getListTransfer();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.xtext.signal.ListTransfer#getInterchanges <em>Interchanges</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference list '<em>Interchanges</em>'.
	 * @see org.eclipse.osbp.xtext.signal.ListTransfer#getInterchanges()
	 * @see #getListTransfer()
	 * @generated
	 */
	EReference getListTransfer_Interchanges();

	/**
	 * Returns the meta object for enum '{@link org.eclipse.osbp.xtext.signal.SignalHandlerTypeEnum <em>Signal Handler Type Enum</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for enum '<em>Signal Handler Type Enum</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalHandlerTypeEnum
	 * @generated
	 */
	EEnum getSignalHandlerTypeEnum();

	/**
	 * Returns the meta object for enum '{@link org.eclipse.osbp.xtext.signal.SignalTypeEnum <em>Signal Type Enum</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for enum '<em>Signal Type Enum</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalTypeEnum
	 * @generated
	 */
	EEnum getSignalTypeEnum();

	/**
	 * Returns the meta object for enum '{@link org.eclipse.osbp.xtext.signal.SignalActionEnum <em>Signal Action Enum</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for enum '<em>Signal Action Enum</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalActionEnum
	 * @generated
	 */
	EEnum getSignalActionEnum();

	/**
	 * Returns the meta object for enum '{@link org.eclipse.osbp.xtext.signal.SignalExecutionTypeEnum <em>Signal Execution Type Enum</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for enum '<em>Signal Execution Type Enum</em>'.
	 * @see org.eclipse.osbp.xtext.signal.SignalExecutionTypeEnum
	 * @generated
	 */
	EEnum getSignalExecutionTypeEnum();

	/**
	 * Returns the meta object for data type '{@link org.eclipse.emf.ecore.InternalEObject <em>Internal EObject</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for data type '<em>Internal EObject</em>'.
	 * @see org.eclipse.emf.ecore.InternalEObject
	 * @model instanceClass="org.eclipse.emf.ecore.InternalEObject"
	 * @generated
	 */
	EDataType getInternalEObject();

	/**
	 * 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
	 */
	SignalDSLFactory getSignalDSLFactory();

	/**
	 * <!-- 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.osbp.xtext.signal.impl.SignalModelImpl <em>Signal Model</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalModelImpl
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalModel()
		 * @generated
		 */
		EClass SIGNAL_MODEL = eINSTANCE.getSignalModel();

		/**
		 * The meta object literal for the '<em><b>Import Section</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference SIGNAL_MODEL__IMPORT_SECTION = eINSTANCE.getSignalModel_ImportSection();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalLazyResolverImpl <em>Signal Lazy Resolver</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalLazyResolverImpl
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalLazyResolver()
		 * @generated
		 */
		EClass SIGNAL_LAZY_RESOLVER = eINSTANCE.getSignalLazyResolver();

		/**
		 * The meta object literal for the '<em><b>EResolve Proxy</b></em>' operation.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EOperation SIGNAL_LAZY_RESOLVER___ERESOLVE_PROXY__INTERNALEOBJECT = eINSTANCE.getSignalLazyResolver__EResolveProxy__InternalEObject();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalPackageImpl <em>Signal Package</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalPackageImpl
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalPackage()
		 * @generated
		 */
		EClass SIGNAL_PACKAGE = eINSTANCE.getSignalPackage();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalBaseImpl <em>Signal Base</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalBaseImpl
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalBase()
		 * @generated
		 */
		EClass SIGNAL_BASE = eINSTANCE.getSignalBase();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalWatcherImpl <em>Signal Watcher</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalWatcherImpl
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalWatcher()
		 * @generated
		 */
		EClass SIGNAL_WATCHER = eINSTANCE.getSignalWatcher();

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

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

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalHandlerImpl <em>Signal Handler</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalHandlerImpl
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalHandler()
		 * @generated
		 */
		EClass SIGNAL_HANDLER = eINSTANCE.getSignalHandler();

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

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

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

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.SignalProcessor <em>Signal Processor</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.SignalProcessor
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalProcessor()
		 * @generated
		 */
		EClass SIGNAL_PROCESSOR = eINSTANCE.getSignalProcessor();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.impl.SignalDatainterchangeImpl <em>Signal Datainterchange</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDatainterchangeImpl
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalDatainterchange()
		 * @generated
		 */
		EClass SIGNAL_DATAINTERCHANGE = eINSTANCE.getSignalDatainterchange();

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

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.impl.DataTransferImpl <em>Data Transfer</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.impl.DataTransferImpl
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getDataTransfer()
		 * @generated
		 */
		EClass DATA_TRANSFER = eINSTANCE.getDataTransfer();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.impl.SingleTransferImpl <em>Single Transfer</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.impl.SingleTransferImpl
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSingleTransfer()
		 * @generated
		 */
		EClass SINGLE_TRANSFER = eINSTANCE.getSingleTransfer();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.impl.ListTransferImpl <em>List Transfer</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.impl.ListTransferImpl
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getListTransfer()
		 * @generated
		 */
		EClass LIST_TRANSFER = eINSTANCE.getListTransfer();

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.SignalHandlerTypeEnum <em>Signal Handler Type Enum</em>}' enum.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.SignalHandlerTypeEnum
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalHandlerTypeEnum()
		 * @generated
		 */
		EEnum SIGNAL_HANDLER_TYPE_ENUM = eINSTANCE.getSignalHandlerTypeEnum();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.SignalTypeEnum <em>Signal Type Enum</em>}' enum.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.SignalTypeEnum
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalTypeEnum()
		 * @generated
		 */
		EEnum SIGNAL_TYPE_ENUM = eINSTANCE.getSignalTypeEnum();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.SignalActionEnum <em>Signal Action Enum</em>}' enum.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.SignalActionEnum
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalActionEnum()
		 * @generated
		 */
		EEnum SIGNAL_ACTION_ENUM = eINSTANCE.getSignalActionEnum();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.signal.SignalExecutionTypeEnum <em>Signal Execution Type Enum</em>}' enum.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.xtext.signal.SignalExecutionTypeEnum
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getSignalExecutionTypeEnum()
		 * @generated
		 */
		EEnum SIGNAL_EXECUTION_TYPE_ENUM = eINSTANCE.getSignalExecutionTypeEnum();

		/**
		 * The meta object literal for the '<em>Internal EObject</em>' data type.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.emf.ecore.InternalEObject
		 * @see org.eclipse.osbp.xtext.signal.impl.SignalDSLPackageImpl#getInternalEObject()
		 * @generated
		 */
		EDataType INTERNAL_EOBJECT = eINSTANCE.getInternalEObject();

	}

} //SignalDSLPackage
