/**
 * Copyright (c) 2014, Loetz GmbH&Co.KG (Heidelberg)
 *  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 
 * 
 *  Based on ideas from Xtext, Xtend, Xcore
 *   
 *  Contributors:  
 *  		Joerg Riegel - Initial implementation 
 *  
 */
package org.eclipse.osbp.xtext.datainterchange;

import org.eclipse.emf.common.util.EList;

import org.eclipse.osbp.dsl.semantic.entity.LEntity;
import org.eclipse.osbp.dsl.semantic.entity.LEntityAttribute;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Data Interchange Bean</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getEntity <em>Entity</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#isMarkLatestImport <em>Mark Latest Import</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#isMarkLatestExport <em>Mark Latest Export</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#isHasBlobMapping <em>Has Blob Mapping</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getLatestProperty <em>Latest Property</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getLatestExpProperty <em>Latest Exp Property</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getElementMap <em>Element Map</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getNodeName <em>Node Name</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getLookup <em>Lookup</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getFormat <em>Format</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getExpression <em>Expression</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getMappings <em>Mappings</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getLookupKeys <em>Lookup Keys</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getExportExposes <em>Export Exposes</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getExportFilter <em>Export Filter</em>}</li>
 * </ul>
 *
 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean()
 * @model
 * @generated
 */
public interface DataInterchangeBean extends DataInterchangeLazyResolver {
	/**
	 * Returns the value of the '<em><b>Entity</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Entity</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Entity</em>' reference.
	 * @see #setEntity(LEntity)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_Entity()
	 * @model
	 * @generated
	 */
	LEntity getEntity();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getEntity <em>Entity</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Entity</em>' reference.
	 * @see #getEntity()
	 * @generated
	 */
	void setEntity(LEntity value);

	/**
	 * Returns the value of the '<em><b>Mark Latest Import</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Mark Latest Import</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Mark Latest Import</em>' attribute.
	 * @see #setMarkLatestImport(boolean)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_MarkLatestImport()
	 * @model unique="false"
	 * @generated
	 */
	boolean isMarkLatestImport();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#isMarkLatestImport <em>Mark Latest Import</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Mark Latest Import</em>' attribute.
	 * @see #isMarkLatestImport()
	 * @generated
	 */
	void setMarkLatestImport(boolean value);

	/**
	 * Returns the value of the '<em><b>Mark Latest Export</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Mark Latest Export</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Mark Latest Export</em>' attribute.
	 * @see #setMarkLatestExport(boolean)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_MarkLatestExport()
	 * @model unique="false"
	 * @generated
	 */
	boolean isMarkLatestExport();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#isMarkLatestExport <em>Mark Latest Export</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Mark Latest Export</em>' attribute.
	 * @see #isMarkLatestExport()
	 * @generated
	 */
	void setMarkLatestExport(boolean value);

	/**
	 * Returns the value of the '<em><b>Has Blob Mapping</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Has Blob Mapping</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Has Blob Mapping</em>' attribute.
	 * @see #setHasBlobMapping(boolean)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_HasBlobMapping()
	 * @model unique="false"
	 * @generated
	 */
	boolean isHasBlobMapping();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#isHasBlobMapping <em>Has Blob Mapping</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Has Blob Mapping</em>' attribute.
	 * @see #isHasBlobMapping()
	 * @generated
	 */
	void setHasBlobMapping(boolean value);

	/**
	 * Returns the value of the '<em><b>Latest Property</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Latest Property</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Latest Property</em>' reference.
	 * @see #setLatestProperty(LEntityAttribute)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_LatestProperty()
	 * @model
	 * @generated
	 */
	LEntityAttribute getLatestProperty();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getLatestProperty <em>Latest Property</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Latest Property</em>' reference.
	 * @see #getLatestProperty()
	 * @generated
	 */
	void setLatestProperty(LEntityAttribute value);

	/**
	 * Returns the value of the '<em><b>Latest Exp Property</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Latest Exp Property</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Latest Exp Property</em>' reference.
	 * @see #setLatestExpProperty(LEntityAttribute)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_LatestExpProperty()
	 * @model
	 * @generated
	 */
	LEntityAttribute getLatestExpProperty();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getLatestExpProperty <em>Latest Exp Property</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Latest Exp Property</em>' reference.
	 * @see #getLatestExpProperty()
	 * @generated
	 */
	void setLatestExpProperty(LEntityAttribute value);

	/**
	 * Returns the value of the '<em><b>Element Map</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Element Map</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Element Map</em>' attribute.
	 * @see #setElementMap(String)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_ElementMap()
	 * @model unique="false"
	 * @generated
	 */
	String getElementMap();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getElementMap <em>Element Map</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Element Map</em>' attribute.
	 * @see #getElementMap()
	 * @generated
	 */
	void setElementMap(String value);

	/**
	 * Returns the value of the '<em><b>Node Name</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Node Name</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Node Name</em>' attribute.
	 * @see #setNodeName(String)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_NodeName()
	 * @model unique="false"
	 * @generated
	 */
	String getNodeName();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getNodeName <em>Node Name</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Node Name</em>' attribute.
	 * @see #getNodeName()
	 * @generated
	 */
	void setNodeName(String value);

	/**
	 * Returns the value of the '<em><b>Lookup</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeLookup}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Lookup</em>' containment reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Lookup</em>' containment reference list.
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_Lookup()
	 * @model containment="true"
	 * @generated
	 */
	EList<DataInterchangeLookup> getLookup();

	/**
	 * Returns the value of the '<em><b>Format</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeFormat}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Format</em>' containment reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Format</em>' containment reference list.
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_Format()
	 * @model containment="true"
	 * @generated
	 */
	EList<DataInterchangeFormat> getFormat();

	/**
	 * Returns the value of the '<em><b>Expression</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeExpression}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Expression</em>' containment reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Expression</em>' containment reference list.
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_Expression()
	 * @model containment="true"
	 * @generated
	 */
	EList<DataInterchangeExpression> getExpression();

	/**
	 * Returns the value of the '<em><b>Mappings</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeMapping}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Mappings</em>' containment reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Mappings</em>' containment reference list.
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_Mappings()
	 * @model containment="true"
	 * @generated
	 */
	EList<DataInterchangeMapping> getMappings();

	/**
	 * Returns the value of the '<em><b>Lookup Keys</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeKey}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Lookup Keys</em>' containment reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Lookup Keys</em>' containment reference list.
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_LookupKeys()
	 * @model containment="true"
	 * @generated
	 */
	EList<DataInterchangeKey> getLookupKeys();

	/**
	 * Returns the value of the '<em><b>Export Exposes</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeExpose}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Export Exposes</em>' containment reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Export Exposes</em>' containment reference list.
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_ExportExposes()
	 * @model containment="true"
	 * @generated
	 */
	EList<DataInterchangeExpose> getExportExposes();

	/**
	 * Returns the value of the '<em><b>Export Filter</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Export Filter</em>' containment reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Export Filter</em>' containment reference.
	 * @see #setExportFilter(DataInterchangeExportFilter)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBean_ExportFilter()
	 * @model containment="true"
	 * @generated
	 */
	DataInterchangeExportFilter getExportFilter();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBean#getExportFilter <em>Export Filter</em>}' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Export Filter</em>' containment reference.
	 * @see #getExportFilter()
	 * @generated
	 */
	void setExportFilter(DataInterchangeExportFilter value);

} // DataInterchangeBean
