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


/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Transformer</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer#getNum_encoder_layers <em>Num encoder layers</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer#getNum_decoder_layers <em>Num decoder layers</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer#getCustom_encoder <em>Custom encoder</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer#getCustom_decoder <em>Custom decoder</em>}</li>
 * </ul>
 *
 * @see org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer_layersPackage#getTransformer()
 * @model
 * @generated
 */
public interface Transformer extends Transformer_layers_1 {
	/**
	 * Returns the value of the '<em><b>Num encoder layers</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Num encoder 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 encoder layers</em>' attribute.
	 * @see #setNum_encoder_layers(int)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer_layersPackage#getTransformer_Num_encoder_layers()
	 * @model dataType="org.eclipse.uml2.types.Integer" required="true" ordered="false"
	 *        annotation="http://www.eclipse.org/uml2/2.0.0/UML originalName='num_encoder_layers '"
	 * @generated
	 */
	int getNum_encoder_layers();

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

	/**
	 * Returns the value of the '<em><b>Num decoder layers</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Num decoder 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 decoder layers</em>' attribute.
	 * @see #setNum_decoder_layers(int)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer_layersPackage#getTransformer_Num_decoder_layers()
	 * @model dataType="org.eclipse.uml2.types.Integer" required="true" ordered="false"
	 *        annotation="http://www.eclipse.org/uml2/2.0.0/UML originalName='num_decoder_layers '"
	 * @generated
	 */
	int getNum_decoder_layers();

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

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

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer#getCustom_encoder <em>Custom encoder</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Custom encoder</em>' reference.
	 * @see #getCustom_encoder()
	 * @generated
	 */
	void setCustom_encoder(TransformerEncoder value);

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

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Transformer_layers.Transformer#getCustom_decoder <em>Custom decoder</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Custom decoder</em>' reference.
	 * @see #getCustom_decoder()
	 * @generated
	 */
	void setCustom_decoder(TransformerDecoder value);

} // Transformer
