/**
 * 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.reportdsl;

import org.eclipse.osbp.xtext.datamartdsl.DatamartProperty;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Datamart Table Group</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.reportdsl.DatamartTableGroup#getGroupingRef <em>Grouping Ref</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.reportdsl.DatamartTableGroup#getHeader <em>Header</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.reportdsl.DatamartTableGroup#getFooter <em>Footer</em>}</li>
 * </ul>
 * </p>
 *
 * @see org.eclipse.osbp.xtext.reportdsl.ReportDSLPackage#getDatamartTableGroup()
 * @model
 * @generated
 */
public interface DatamartTableGroup extends ReportBase, WithHeaderFooter {
	/**
	 * Returns the value of the '<em><b>Grouping Ref</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Grouping Ref</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Grouping Ref</em>' reference.
	 * @see #setGroupingRef(DatamartProperty)
	 * @see org.eclipse.osbp.xtext.reportdsl.ReportDSLPackage#getDatamartTableGroup_GroupingRef()
	 * @model
	 * @generated
	 */
	DatamartProperty getGroupingRef();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.reportdsl.DatamartTableGroup#getGroupingRef <em>Grouping Ref</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Grouping Ref</em>' reference.
	 * @see #getGroupingRef()
	 * @generated
	 */
	void setGroupingRef(DatamartProperty value);

	/**
	 * Returns the value of the '<em><b>Header</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Header</em>' containment reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Header</em>' containment reference.
	 * @see #setHeader(DatamartTableGroupHeader)
	 * @see org.eclipse.osbp.xtext.reportdsl.ReportDSLPackage#getDatamartTableGroup_Header()
	 * @model containment="true"
	 * @generated
	 */
	DatamartTableGroupHeader getHeader();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.reportdsl.DatamartTableGroup#getHeader <em>Header</em>}' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Header</em>' containment reference.
	 * @see #getHeader()
	 * @generated
	 */
	void setHeader(DatamartTableGroupHeader value);

	/**
	 * Returns the value of the '<em><b>Footer</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Footer</em>' containment reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Footer</em>' containment reference.
	 * @see #setFooter(DatamartTableGroupFooter)
	 * @see org.eclipse.osbp.xtext.reportdsl.ReportDSLPackage#getDatamartTableGroup_Footer()
	 * @model containment="true"
	 * @generated
	 */
	DatamartTableGroupFooter getFooter();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.reportdsl.DatamartTableGroup#getFooter <em>Footer</em>}' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Footer</em>' containment reference.
	 * @see #getFooter()
	 * @generated
	 */
	void setFooter(DatamartTableGroupFooter value);

} // DatamartTableGroup
