/**
 * 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
 *  
 *  Contributors:                                                      
 *     Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 *  
 *  generated from AuthoritarionDSL.xcore
 * 
 *  
 */
package org.eclipse.osbp.xtext.authorizationdsl;

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

import org.eclipse.osbp.xtext.blip.Blip;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Role Blip Process</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.authorizationdsl.RoleBlipProcess#getProcess <em>Process</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.authorizationdsl.RoleBlipProcess#getProcessStartAuthorized <em>Process Start Authorized</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.authorizationdsl.RoleBlipProcess#getAllUserTasks <em>All User Tasks</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.authorizationdsl.RoleBlipProcess#getUserTasks <em>User Tasks</em>}</li>
 * </ul>
 *
 * @see org.eclipse.osbp.xtext.authorizationdsl.AuthorizationDSLPackage#getRoleBlipProcess()
 * @model
 * @generated
 */
public interface RoleBlipProcess extends RoleElement {
	/**
	 * Returns the value of the '<em><b>Process</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Process</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Process</em>' reference.
	 * @see #setProcess(Blip)
	 * @see org.eclipse.osbp.xtext.authorizationdsl.AuthorizationDSLPackage#getRoleBlipProcess_Process()
	 * @model
	 * @generated
	 */
	Blip getProcess();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.authorizationdsl.RoleBlipProcess#getProcess <em>Process</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Process</em>' reference.
	 * @see #getProcess()
	 * @generated
	 */
	void setProcess(Blip value);

	/**
	 * Returns the value of the '<em><b>Process Start Authorized</b></em>' attribute.
	 * The literals are from the enumeration {@link org.eclipse.osbp.xtext.authorizationdsl.RoleBlipProcessEnum}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Process Start Authorized</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Process Start Authorized</em>' attribute.
	 * @see org.eclipse.osbp.xtext.authorizationdsl.RoleBlipProcessEnum
	 * @see #setProcessStartAuthorized(RoleBlipProcessEnum)
	 * @see org.eclipse.osbp.xtext.authorizationdsl.AuthorizationDSLPackage#getRoleBlipProcess_ProcessStartAuthorized()
	 * @model unique="false"
	 * @generated
	 */
	RoleBlipProcessEnum getProcessStartAuthorized();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.authorizationdsl.RoleBlipProcess#getProcessStartAuthorized <em>Process Start Authorized</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Process Start Authorized</em>' attribute.
	 * @see org.eclipse.osbp.xtext.authorizationdsl.RoleBlipProcessEnum
	 * @see #getProcessStartAuthorized()
	 * @generated
	 */
	void setProcessStartAuthorized(RoleBlipProcessEnum value);

	/**
	 * Returns the value of the '<em><b>All User Tasks</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>All User Tasks</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>All User Tasks</em>' containment reference.
	 * @see #setAllUserTasks(RoleBlipAllUserTasks)
	 * @see org.eclipse.osbp.xtext.authorizationdsl.AuthorizationDSLPackage#getRoleBlipProcess_AllUserTasks()
	 * @model containment="true"
	 * @generated
	 */
	RoleBlipAllUserTasks getAllUserTasks();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.authorizationdsl.RoleBlipProcess#getAllUserTasks <em>All User Tasks</em>}' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>All User Tasks</em>' containment reference.
	 * @see #getAllUserTasks()
	 * @generated
	 */
	void setAllUserTasks(RoleBlipAllUserTasks value);

	/**
	 * Returns the value of the '<em><b>User Tasks</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.osbp.xtext.authorizationdsl.RoleBlipUserTask}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>User Tasks</em>' containment reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>User Tasks</em>' containment reference list.
	 * @see org.eclipse.osbp.xtext.authorizationdsl.AuthorizationDSLPackage#getRoleBlipProcess_UserTasks()
	 * @model containment="true"
	 * @generated
	 */
	EList<RoleBlipUserTask> getUserTasks();

} // RoleBlipProcess
