/**
 *  Copyright (c)2020 CEA LIST, Committer Name, and others.
 * 
 *  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
 * 
 *  Contributors:
 *  CEA LIST - Initial API and implementation
 *  Patrick Tessier (CEA LIST) Patrick.tessier@cea.fr 
 *  Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr 
 * 
 */
package org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR;

import org.eclipse.emf.ecore.EObject;

import org.eclipse.uml2.uml.NamedElement;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Link</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Link#getBase_NamedElement <em>Base Named Element</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Link#getLinkability <em>Linkability</em>}</li>
 * </ul>
 *
 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.pdp4engReqGDPRPackage#getLink()
 * @model
 * @generated
 */
public interface Link extends EObject {
	/**
	 * Returns the value of the '<em><b>Base Named Element</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Base Named Element</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Base Named Element</em>' reference.
	 * @see #setBase_NamedElement(NamedElement)
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.pdp4engReqGDPRPackage#getLink_Base_NamedElement()
	 * @model ordered="false"
	 * @generated
	 */
	NamedElement getBase_NamedElement();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Link#getBase_NamedElement <em>Base Named Element</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Base Named Element</em>' reference.
	 * @see #getBase_NamedElement()
	 * @generated
	 */
	void setBase_NamedElement(NamedElement value);

	/**
	 * Returns the value of the '<em><b>Linkability</b></em>' attribute.
	 * The literals are from the enumeration {@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Linkability</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Linkability</em>' attribute.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability
	 * @see #setLinkability(Linkability)
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.pdp4engReqGDPRPackage#getLink_Linkability()
	 * @model required="true" ordered="false"
	 * @generated
	 */
	Linkability getLinkability();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Link#getLinkability <em>Linkability</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Linkability</em>' attribute.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability
	 * @see #getLinkability()
	 * @generated
	 */
	void setLinkability(Linkability value);

} // Link
