/**
 *                                                                            
 * Copyright (c) 2011, 2016 - 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 
 */
 package org.eclipse.osbp.infogrid.model.gridsource;

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 enum,</li>
 *   <li>and each data type</li>
 * </ul>
 * <!-- end-user-doc -->
 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceFactory
 * @model kind="package"
 * @generated
 */
public interface CxGridSourcePackage extends EPackage {
	/**
	 * The package name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNAME = "gridsource";

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

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

	/**
	 * The singleton instance of the package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	CxGridSourcePackage eINSTANCE = org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl.init();

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceImpl <em>Cx Grid Source</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridSource()
	 * @generated
	 */
	int CX_GRID_SOURCE = 0;

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

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

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

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

	/**
	 * The feature id for the '<em><b>Root Type FQN</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_SOURCE__ROOT_TYPE_FQN = 4;

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

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

	/**
	 * The feature id for the '<em><b>Selection Event Topic</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_SOURCE__SELECTION_EVENT_TOPIC = 7;

	/**
	 * The number of structural features of the '<em>Cx Grid Source</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_SOURCE_FEATURE_COUNT = 8;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceInputImpl <em>Input</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceInputImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridSourceInput()
	 * @generated
	 */
	int CX_GRID_SOURCE_INPUT = 1;

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

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

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

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

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridPropertyImpl <em>Cx Grid Property</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridPropertyImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridProperty()
	 * @generated
	 */
	int CX_GRID_PROPERTY = 2;

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

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

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

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

	/**
	 * The number of structural features of the '<em>Cx Grid Property</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROPERTY_FEATURE_COUNT = 4;


	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridNestedFieldImpl <em>Cx Grid Nested Field</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridNestedFieldImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridNestedField()
	 * @generated
	 */
	int CX_GRID_NESTED_FIELD = 3;

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

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

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

	/**
	 * The number of structural features of the '<em>Cx Grid Nested Field</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_NESTED_FIELD_FEATURE_COUNT = 3;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridNestedPathImpl <em>Cx Grid Nested Path</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridNestedPathImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridNestedPath()
	 * @generated
	 */
	int CX_GRID_NESTED_PATH = 4;

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

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

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

	/**
	 * The number of structural features of the '<em>Cx Grid Nested Path</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_NESTED_PATH_FEATURE_COUNT = 3;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceEQFilterImpl <em>EQ Filter</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceEQFilterImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridSourceEQFilter()
	 * @generated
	 */
	int CX_GRID_SOURCE_EQ_FILTER = 5;

	/**
	 * The feature id for the '<em><b>Input Type Property Path</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_SOURCE_EQ_FILTER__INPUT_TYPE_PROPERTY_PATH = 0;

	/**
	 * The feature id for the '<em><b>Root Type Property Path</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_SOURCE_EQ_FILTER__ROOT_TYPE_PROPERTY_PATH = 1;

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

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSource <em>Cx Grid Source</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Source</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSource
	 * @generated
	 */
	EClass getCxGridSource();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getId <em>Id</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Id</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getId()
	 * @see #getCxGridSource()
	 * @generated
	 */
	EAttribute getCxGridSource_Id();

	/**
	 * Returns the meta object for the attribute list '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getTags <em>Tags</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute list '<em>Tags</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getTags()
	 * @see #getCxGridSource()
	 * @generated
	 */
	EAttribute getCxGridSource_Tags();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getKind <em>Kind</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Kind</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getKind()
	 * @see #getCxGridSource()
	 * @generated
	 */
	EAttribute getCxGridSource_Kind();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getRootType <em>Root Type</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Root Type</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getRootType()
	 * @see #getCxGridSource()
	 * @generated
	 */
	EReference getCxGridSource_RootType();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getRootTypeFQN <em>Root Type FQN</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Root Type FQN</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getRootTypeFQN()
	 * @see #getCxGridSource()
	 * @generated
	 */
	EAttribute getCxGridSource_RootTypeFQN();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getProperties <em>Properties</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference list '<em>Properties</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getProperties()
	 * @see #getCxGridSource()
	 * @generated
	 */
	EReference getCxGridSource_Properties();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getInputs <em>Inputs</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference list '<em>Inputs</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getInputs()
	 * @see #getCxGridSource()
	 * @generated
	 */
	EReference getCxGridSource_Inputs();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getSelectionEventTopic <em>Selection Event Topic</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Selection Event Topic</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSource#getSelectionEventTopic()
	 * @see #getCxGridSource()
	 * @generated
	 */
	EAttribute getCxGridSource_SelectionEventTopic();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceInput <em>Input</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Input</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceInput
	 * @generated
	 */
	EClass getCxGridSourceInput();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceInput#getInputType <em>Input Type</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Input Type</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceInput#getInputType()
	 * @see #getCxGridSourceInput()
	 * @generated
	 */
	EReference getCxGridSourceInput_InputType();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceInput#getInputTypeFQN <em>Input Type FQN</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Input Type FQN</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceInput#getInputTypeFQN()
	 * @see #getCxGridSourceInput()
	 * @generated
	 */
	EAttribute getCxGridSourceInput_InputTypeFQN();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceInput#getFilters <em>Filters</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference list '<em>Filters</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceInput#getFilters()
	 * @see #getCxGridSourceInput()
	 * @generated
	 */
	EReference getCxGridSourceInput_Filters();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty <em>Cx Grid Property</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Property</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty
	 * @generated
	 */
	EClass getCxGridProperty();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty#getPath <em>Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty#getPath()
	 * @see #getCxGridProperty()
	 * @generated
	 */
	EReference getCxGridProperty_Path();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty#getStyle <em>Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty#getStyle()
	 * @see #getCxGridProperty()
	 * @generated
	 */
	EReference getCxGridProperty_Style();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty#getDotPath <em>Dot Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Dot Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty#getDotPath()
	 * @see #getCxGridProperty()
	 * @generated
	 */
	EAttribute getCxGridProperty_DotPath();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty#isEditable <em>Editable</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Editable</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty#isEditable()
	 * @see #getCxGridProperty()
	 * @generated
	 */
	EAttribute getCxGridProperty_Editable();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedField <em>Cx Grid Nested Field</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Nested Field</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedField
	 * @generated
	 */
	EClass getCxGridNestedField();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedField#getField <em>Field</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Field</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedField#getField()
	 * @see #getCxGridNestedField()
	 * @generated
	 */
	EReference getCxGridNestedField_Field();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedField#getPath <em>Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedField#getPath()
	 * @see #getCxGridNestedField()
	 * @generated
	 */
	EReference getCxGridNestedField_Path();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedField#getDotPath <em>Dot Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Dot Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedField#getDotPath()
	 * @see #getCxGridNestedField()
	 * @generated
	 */
	EAttribute getCxGridNestedField_DotPath();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedPath <em>Cx Grid Nested Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Nested Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedPath
	 * @generated
	 */
	EClass getCxGridNestedPath();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedPath#getField <em>Field</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Field</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedPath#getField()
	 * @see #getCxGridNestedPath()
	 * @generated
	 */
	EReference getCxGridNestedPath_Field();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedPath#getPath <em>Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedPath#getPath()
	 * @see #getCxGridNestedPath()
	 * @generated
	 */
	EReference getCxGridNestedPath_Path();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedPath#getDotPath <em>Dot Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Dot Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridNestedPath#getDotPath()
	 * @see #getCxGridNestedPath()
	 * @generated
	 */
	EAttribute getCxGridNestedPath_DotPath();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceEQFilter <em>EQ Filter</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>EQ Filter</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceEQFilter
	 * @generated
	 */
	EClass getCxGridSourceEQFilter();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceEQFilter#getInputTypePropertyPath <em>Input Type Property Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Input Type Property Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceEQFilter#getInputTypePropertyPath()
	 * @see #getCxGridSourceEQFilter()
	 * @generated
	 */
	EReference getCxGridSourceEQFilter_InputTypePropertyPath();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceEQFilter#getRootTypePropertyPath <em>Root Type Property Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Root Type Property Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceEQFilter#getRootTypePropertyPath()
	 * @see #getCxGridSourceEQFilter()
	 * @generated
	 */
	EReference getCxGridSourceEQFilter_RootTypePropertyPath();

	/**
	 * 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
	 */
	CxGridSourceFactory getCxGridSourceFactory();

	/**
	 * <!-- 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 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.infogrid.model.gridsource.impl.CxGridSourceImpl <em>Cx Grid Source</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridSource()
		 * @generated
		 */
		EClass CX_GRID_SOURCE = eINSTANCE.getCxGridSource();

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

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

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

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

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

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

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

		/**
		 * The meta object literal for the '<em><b>Selection Event Topic</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_SOURCE__SELECTION_EVENT_TOPIC = eINSTANCE.getCxGridSource_SelectionEventTopic();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceInputImpl <em>Input</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceInputImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridSourceInput()
		 * @generated
		 */
		EClass CX_GRID_SOURCE_INPUT = eINSTANCE.getCxGridSourceInput();

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

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridPropertyImpl <em>Cx Grid Property</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridPropertyImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridProperty()
		 * @generated
		 */
		EClass CX_GRID_PROPERTY = eINSTANCE.getCxGridProperty();

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

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

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridNestedFieldImpl <em>Cx Grid Nested Field</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridNestedFieldImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridNestedField()
		 * @generated
		 */
		EClass CX_GRID_NESTED_FIELD = eINSTANCE.getCxGridNestedField();

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

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridNestedPathImpl <em>Cx Grid Nested Path</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridNestedPathImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridNestedPath()
		 * @generated
		 */
		EClass CX_GRID_NESTED_PATH = eINSTANCE.getCxGridNestedPath();

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

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

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

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceEQFilterImpl <em>EQ Filter</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourceEQFilterImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.impl.CxGridSourcePackageImpl#getCxGridSourceEQFilter()
		 * @generated
		 */
		EClass CX_GRID_SOURCE_EQ_FILTER = eINSTANCE.getCxGridSourceEQFilter();

		/**
		 * The meta object literal for the '<em><b>Input Type Property Path</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CX_GRID_SOURCE_EQ_FILTER__INPUT_TYPE_PROPERTY_PATH = eINSTANCE.getCxGridSourceEQFilter_InputTypePropertyPath();

		/**
		 * The meta object literal for the '<em><b>Root Type Property Path</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CX_GRID_SOURCE_EQ_FILTER__ROOT_TYPE_PROPERTY_PATH = eINSTANCE.getCxGridSourceEQFilter_RootTypePropertyPath();

	}

} //CxGridSourcePackage
