/**
 * 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.osbp.dsl.semantic.entity.LEntityAttribute;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Data Interchange Expression</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeExpression#getTargetProperty <em>Target Property</em>}</li>
 * </ul>
 *
 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeExpression()
 * @model interface="true" abstract="true"
 * @generated
 */
public interface DataInterchangeExpression extends DataInterchangeLazyResolver {
	/**
	 * Returns the value of the '<em><b>Target Property</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Target 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>Target Property</em>' reference.
	 * @see #setTargetProperty(LEntityAttribute)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeExpression_TargetProperty()
	 * @model
	 * @generated
	 */
	LEntityAttribute getTargetProperty();

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

} // DataInterchangeExpression
