/**
 * 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 File CSV</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeFileCSV#getFileURL <em>File URL</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeFileCSV#getDelimiter <em>Delimiter</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeFileCSV#getQuoteCharacter <em>Quote Character</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeFileCSV#getSkipLines <em>Skip Lines</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeFileCSV#isIndent <em>Indent</em>}</li>
 * </ul>
 *
 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeFileCSV()
 * @model
 * @generated
 */
public interface DataInterchangeFileCSV extends DataInterchangeFile {
	/**
	 * Returns the value of the '<em><b>File URL</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>File URL</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>File URL</em>' attribute.
	 * @see #setFileURL(String)
	 * @see org.eclipse.osbp.xtext.datainterchange.DataDSLPackage#getDataInterchangeFileCSV_FileURL()
	 * @model unique="false"
	 * @generated
	 */
	String getFileURL();

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

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

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

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

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeFileCSV#getQuoteCharacter <em>Quote Character</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Quote Character</em>' attribute.
	 * @see #getQuoteCharacter()
	 * @generated
	 */
	void setQuoteCharacter(String value);

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

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeFileCSV#getSkipLines <em>Skip Lines</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Skip Lines</em>' attribute.
	 * @see #getSkipLines()
	 * @generated
	 */
	void setSkipLines(int value);

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

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datainterchange.DataInterchangeFileCSV#isIndent <em>Indent</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Indent</em>' attribute.
	 * @see #isIndent()
	 * @generated
	 */
	void setIndent(boolean value);

} // DataInterchangeFileCSV
