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

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

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Entity Mock Referenced Object Attribute</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.entitymock.EntityMockReferencedObjectAttribute#getTemplate <em>Template</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.entitymock.EntityMockReferencedObjectAttribute#getEmbedded <em>Embedded</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.entitymock.EntityMockReferencedObjectAttribute#getAttribute <em>Attribute</em>}</li>
 * </ul>
 *
 * @see org.eclipse.osbp.xtext.entitymock.EntityMockDSLPackage#getEntityMockReferencedObjectAttribute()
 * @model
 * @generated
 */
public interface EntityMockReferencedObjectAttribute extends EntityMockLazyResolver {
	/**
	 * Returns the value of the '<em><b>Template</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Template</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Template</em>' reference.
	 * @see #setTemplate(EntityMockTemplate)
	 * @see org.eclipse.osbp.xtext.entitymock.EntityMockDSLPackage#getEntityMockReferencedObjectAttribute_Template()
	 * @model
	 * @generated
	 */
	EntityMockTemplate getTemplate();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.entitymock.EntityMockReferencedObjectAttribute#getTemplate <em>Template</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Template</em>' reference.
	 * @see #getTemplate()
	 * @generated
	 */
	void setTemplate(EntityMockTemplate value);

	/**
	 * Returns the value of the '<em><b>Embedded</b></em>' reference list.
	 * The list contents are of type {@link org.eclipse.osbp.xtext.entitymock.EntityMockObjectEmbed}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Embedded</em>' reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Embedded</em>' reference list.
	 * @see org.eclipse.osbp.xtext.entitymock.EntityMockDSLPackage#getEntityMockReferencedObjectAttribute_Embedded()
	 * @model
	 * @generated
	 */
	EList<EntityMockObjectEmbed> getEmbedded();

	/**
	 * Returns the value of the '<em><b>Attribute</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Attribute</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Attribute</em>' reference.
	 * @see #setAttribute(IEntityMockObjectUsable)
	 * @see org.eclipse.osbp.xtext.entitymock.EntityMockDSLPackage#getEntityMockReferencedObjectAttribute_Attribute()
	 * @model
	 * @generated
	 */
	IEntityMockObjectUsable getAttribute();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.entitymock.EntityMockReferencedObjectAttribute#getAttribute <em>Attribute</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Attribute</em>' reference.
	 * @see #getAttribute()
	 * @generated
	 */
	void setAttribute(IEntityMockObjectUsable value);

} // EntityMockReferencedObjectAttribute
