/**
 * 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 Mapping</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeMapping#getProperty <em>Property</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeMapping#getData <em>Data</em>}</li>
 * </ul>
 *
 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeMapping()
 * @model interface="true" abstract="true"
 * @generated
 */
public interface DataInterchangeMapping extends DataInterchangeLazyResolver {
	/**
	 * Returns the value of the '<em><b>Property</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>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>Property</em>' reference.
	 * @see #setProperty(LEntityAttribute)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeMapping_Property()
	 * @model
	 * @generated
	 */
	LEntityAttribute getProperty();

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

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

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

} // DataInterchangeMapping
