/**
 * <copyright>
 * </copyright>
 *
 * $Id$
 */
package org.eclipse.stem.core.model;

import org.eclipse.emf.common.util.EList;
import org.eclipse.stem.core.graph.DynamicLabel;


/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Transformation Decorator</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * <ul>
 *   <li>{@link org.eclipse.stem.core.model.TransformationDecorator#getSourceLabels <em>Source Labels</em>}</li>
 * </ul>
 * </p>
 *
 * @see org.eclipse.stem.core.model.ModelPackage#getTransformationDecorator()
 * @model abstract="true"
 * @generated
 */
public interface TransformationDecorator extends NodeDecorator {

	/**
	 * Returns the value of the '<em><b>Source Labels</b></em>' reference list.
	 * The list contents are of type {@link org.eclipse.stem.core.graph.DynamicLabel}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Source Labels</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>Source Labels</em>' reference list.
	 * @see org.eclipse.stem.core.model.ModelPackage#getTransformationDecorator_SourceLabels()
	 * @model
	 * @generated
	 */
	EList<DynamicLabel> getSourceLabels();

} // TransformationDecorator
