/**
 * Copyright (c) 2014, Loetz GmbH&Co.KG (Heidelberg)
 *  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 
 * 
 *  Based on ideas from Xtext, Xtend, Xcore
 *   
 *  Contributors:  
 *  		Joerg Riegel - Initial implementation 
 *  
 */
package org.eclipse.osbp.xtext.datainterchange;


/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Data Interchange Blob Mapping</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBlobMapping#getBlobFileExtension <em>Blob File Extension</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBlobMapping#getBlobPath <em>Blob Path</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBlobMapping#getMimeType <em>Mime Type</em>}</li>
 * </ul>
 *
 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBlobMapping()
 * @model
 * @generated
 */
public interface DataInterchangeBlobMapping extends DataInterchangeMapping {
	/**
	 * Returns the value of the '<em><b>Blob File Extension</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Blob File Extension</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Blob File Extension</em>' attribute.
	 * @see #setBlobFileExtension(String)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBlobMapping_BlobFileExtension()
	 * @model unique="false"
	 * @generated
	 */
	String getBlobFileExtension();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBlobMapping#getBlobFileExtension <em>Blob File Extension</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Blob File Extension</em>' attribute.
	 * @see #getBlobFileExtension()
	 * @generated
	 */
	void setBlobFileExtension(String value);

	/**
	 * Returns the value of the '<em><b>Blob Path</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Blob Path</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Blob Path</em>' attribute.
	 * @see #setBlobPath(String)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBlobMapping_BlobPath()
	 * @model unique="false"
	 * @generated
	 */
	String getBlobPath();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBlobMapping#getBlobPath <em>Blob Path</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Blob Path</em>' attribute.
	 * @see #getBlobPath()
	 * @generated
	 */
	void setBlobPath(String value);

	/**
	 * Returns the value of the '<em><b>Mime Type</b></em>' attribute.
	 * The literals are from the enumeration {@link org.eclipse.osbp.xtext.datainterchange.PredefinedBlobMimeTypeEnum}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Mime Type</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Mime Type</em>' attribute.
	 * @see org.eclipse.osbp.xtext.datainterchange.PredefinedBlobMimeTypeEnum
	 * @see #setMimeType(PredefinedBlobMimeTypeEnum)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeBlobMapping_MimeType()
	 * @model unique="false"
	 * @generated
	 */
	PredefinedBlobMimeTypeEnum getMimeType();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeBlobMapping#getMimeType <em>Mime Type</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Mime Type</em>' attribute.
	 * @see org.eclipse.osbp.xtext.datainterchange.PredefinedBlobMimeTypeEnum
	 * @see #getMimeType()
	 * @generated
	 */
	void setMimeType(PredefinedBlobMimeTypeEnum value);

} // DataInterchangeBlobMapping
