/**
 * Copyright (c) 2020 CEA LIST
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v2.0 which
 * accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 * 
 * SPDX-License-Identifier: EPL-2.0
 * 
 */
package org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers;

import org.eclipse.papyrus.aiml.profile.AIML.Normalization_layers.LayerNorm;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Transformer layers 2</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer_layers_2#getNum_layers <em>Num layers</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer_layers_2#getNorm <em>Norm</em>}</li>
 * </ul>
 *
 * @see org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer_layersPackage#getTransformer_layers_2()
 * @model abstract="true"
 * @generated
 */
public interface Transformer_layers_2 extends Transformer_layers {
	/**
	 * Returns the value of the '<em><b>Num layers</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Num layers</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Num layers</em>' attribute.
	 * @see #setNum_layers(int)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer_layersPackage#getTransformer_layers_2_Num_layers()
	 * @model dataType="org.eclipse.uml2.types.Integer" required="true" ordered="false"
	 * @generated
	 */
	int getNum_layers();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer_layers_2#getNum_layers <em>Num layers</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Num layers</em>' attribute.
	 * @see #getNum_layers()
	 * @generated
	 */
	void setNum_layers(int value);

	/**
	 * Returns the value of the '<em><b>Norm</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Norm</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Norm</em>' reference.
	 * @see #setNorm(LayerNorm)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer_layersPackage#getTransformer_layers_2_Norm()
	 * @model ordered="false"
	 * @generated
	 */
	LayerNorm getNorm();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer_layers_2#getNorm <em>Norm</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Norm</em>' reference.
	 * @see #getNorm()
	 * @generated
	 */
	void setNorm(LayerNorm value);

} // Transformer_layers_2
