/**
 * 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 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:  
 *  		Christophe Loetz - Initial implementation
 *  
 */
package org.eclipse.osbp.xtext.functionlibrarydsl;

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

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Function Library Converter Group</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.functionlibrarydsl.FunctionLibraryConverterGroup#getConvertToModelDatatype <em>Convert To Model Datatype</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.functionlibrarydsl.FunctionLibraryConverterGroup#getConvertToPresentationDatatype <em>Convert To Presentation Datatype</em>}</li>
 * </ul>
 *
 * @see org.eclipse.osbp.xtext.functionlibrarydsl.FunctionLibraryDSLPackage#getFunctionLibraryConverterGroup()
 * @model
 * @generated
 */
public interface FunctionLibraryConverterGroup extends FunctionLibraryGroup {
	/**
	 * Returns the value of the '<em><b>Convert To Model Datatype</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Convert To Model Datatype</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Convert To Model Datatype</em>' reference.
	 * @see #setConvertToModelDatatype(LDataType)
	 * @see org.eclipse.osbp.xtext.functionlibrarydsl.FunctionLibraryDSLPackage#getFunctionLibraryConverterGroup_ConvertToModelDatatype()
	 * @model
	 * @generated
	 */
	LDataType getConvertToModelDatatype();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.functionlibrarydsl.FunctionLibraryConverterGroup#getConvertToModelDatatype <em>Convert To Model Datatype</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Convert To Model Datatype</em>' reference.
	 * @see #getConvertToModelDatatype()
	 * @generated
	 */
	void setConvertToModelDatatype(LDataType value);

	/**
	 * Returns the value of the '<em><b>Convert To Presentation Datatype</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Convert To Presentation Datatype</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Convert To Presentation Datatype</em>' reference.
	 * @see #setConvertToPresentationDatatype(LDataType)
	 * @see org.eclipse.osbp.xtext.functionlibrarydsl.FunctionLibraryDSLPackage#getFunctionLibraryConverterGroup_ConvertToPresentationDatatype()
	 * @model
	 * @generated
	 */
	LDataType getConvertToPresentationDatatype();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.functionlibrarydsl.FunctionLibraryConverterGroup#getConvertToPresentationDatatype <em>Convert To Presentation Datatype</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Convert To Presentation Datatype</em>' reference.
	 * @see #getConvertToPresentationDatatype()
	 * @generated
	 */
	void setConvertToPresentationDatatype(LDataType value);

} // FunctionLibraryConverterGroup
