/**
 *   Copyright (c) 2010 Mia-Software.
 *   All rights reserved. This program and the accompanying materials
 *   are made available under the terms of the Eclipse Public License v1.0
 *   which accompanies this distribution, and is available at
 *   http://www.eclipse.org/legal/epl-v10.html
 *   
 *   Contributors:
 *   
 *       Nicolas Guyomar (Mia-Software) - initial API and implementation
 */
package org.eclipse.modisco.jee.webapp.webapp23;

import org.eclipse.emf.ecore.EFactory;

/**
 * <!-- begin-user-doc -->
 * The <b>Factory</b> for the model.
 * It provides a create method for each non-abstract class of the model.
 * <!-- end-user-doc -->
 * @see org.eclipse.modisco.jee.webapp.webapp23.Webapp23Package
 * @generated
 */
public interface Webapp23Factory extends EFactory {
	/**
	 * The singleton instance of the factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	Webapp23Factory eINSTANCE = org.eclipse.modisco.jee.webapp.webapp23.impl.Webapp23FactoryImpl.init();

	/**
	 * Returns a new object of class '<em>Auth Constraint Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Auth Constraint Type</em>'.
	 * @generated
	 */
	AuthConstraintType createAuthConstraintType();

	/**
	 * Returns a new object of class '<em>Auth Method Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Auth Method Type</em>'.
	 * @generated
	 */
	AuthMethodType createAuthMethodType();

	/**
	 * Returns a new object of class '<em>Context Param Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Context Param Type</em>'.
	 * @generated
	 */
	ContextParamType createContextParamType();

	/**
	 * Returns a new object of class '<em>Description Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Description Type</em>'.
	 * @generated
	 */
	DescriptionType createDescriptionType();

	/**
	 * Returns a new object of class '<em>Display Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Display Name Type</em>'.
	 * @generated
	 */
	DisplayNameType createDisplayNameType();

	/**
	 * Returns a new object of class '<em>Distributable Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Distributable Type</em>'.
	 * @generated
	 */
	DistributableType createDistributableType();

	/**
	 * Returns a new object of class '<em>Document Root</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Document Root</em>'.
	 * @generated
	 */
	DocumentRoot createDocumentRoot();

	/**
	 * Returns a new object of class '<em>Ejb Link Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Ejb Link Type</em>'.
	 * @generated
	 */
	EjbLinkType createEjbLinkType();

	/**
	 * Returns a new object of class '<em>Ejb Local Ref Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Ejb Local Ref Type</em>'.
	 * @generated
	 */
	EjbLocalRefType createEjbLocalRefType();

	/**
	 * Returns a new object of class '<em>Ejb Ref Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Ejb Ref Name Type</em>'.
	 * @generated
	 */
	EjbRefNameType createEjbRefNameType();

	/**
	 * Returns a new object of class '<em>Ejb Ref Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Ejb Ref Type</em>'.
	 * @generated
	 */
	EjbRefType createEjbRefType();

	/**
	 * Returns a new object of class '<em>Ejb Ref Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Ejb Ref Type Type</em>'.
	 * @generated
	 */
	EjbRefTypeType createEjbRefTypeType();

	/**
	 * Returns a new object of class '<em>Env Entry Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Env Entry Name Type</em>'.
	 * @generated
	 */
	EnvEntryNameType createEnvEntryNameType();

	/**
	 * Returns a new object of class '<em>Env Entry Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Env Entry Type</em>'.
	 * @generated
	 */
	EnvEntryType createEnvEntryType();

	/**
	 * Returns a new object of class '<em>Env Entry Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Env Entry Type Type</em>'.
	 * @generated
	 */
	EnvEntryTypeType createEnvEntryTypeType();

	/**
	 * Returns a new object of class '<em>Env Entry Value Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Env Entry Value Type</em>'.
	 * @generated
	 */
	EnvEntryValueType createEnvEntryValueType();

	/**
	 * Returns a new object of class '<em>Error Code Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Error Code Type</em>'.
	 * @generated
	 */
	ErrorCodeType createErrorCodeType();

	/**
	 * Returns a new object of class '<em>Error Page Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Error Page Type</em>'.
	 * @generated
	 */
	ErrorPageType createErrorPageType();

	/**
	 * Returns a new object of class '<em>Exception Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Exception Type Type</em>'.
	 * @generated
	 */
	ExceptionTypeType createExceptionTypeType();

	/**
	 * Returns a new object of class '<em>Extension Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Extension Type</em>'.
	 * @generated
	 */
	ExtensionType createExtensionType();

	/**
	 * Returns a new object of class '<em>Filter Class Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Filter Class Type</em>'.
	 * @generated
	 */
	FilterClassType createFilterClassType();

	/**
	 * Returns a new object of class '<em>Filter Mapping Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Filter Mapping Type</em>'.
	 * @generated
	 */
	FilterMappingType createFilterMappingType();

	/**
	 * Returns a new object of class '<em>Filter Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Filter Name Type</em>'.
	 * @generated
	 */
	FilterNameType createFilterNameType();

	/**
	 * Returns a new object of class '<em>Filter Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Filter Type</em>'.
	 * @generated
	 */
	FilterType createFilterType();

	/**
	 * Returns a new object of class '<em>Form Error Page Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Form Error Page Type</em>'.
	 * @generated
	 */
	FormErrorPageType createFormErrorPageType();

	/**
	 * Returns a new object of class '<em>Form Login Config Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Form Login Config Type</em>'.
	 * @generated
	 */
	FormLoginConfigType createFormLoginConfigType();

	/**
	 * Returns a new object of class '<em>Form Login Page Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Form Login Page Type</em>'.
	 * @generated
	 */
	FormLoginPageType createFormLoginPageType();

	/**
	 * Returns a new object of class '<em>Home Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Home Type</em>'.
	 * @generated
	 */
	HomeType createHomeType();

	/**
	 * Returns a new object of class '<em>Http Method Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Http Method Type</em>'.
	 * @generated
	 */
	HttpMethodType createHttpMethodType();

	/**
	 * Returns a new object of class '<em>Icon Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Icon Type</em>'.
	 * @generated
	 */
	IconType createIconType();

	/**
	 * Returns a new object of class '<em>Init Param Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Init Param Type</em>'.
	 * @generated
	 */
	InitParamType createInitParamType();

	/**
	 * Returns a new object of class '<em>Jsp File Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Jsp File Type</em>'.
	 * @generated
	 */
	JspFileType createJspFileType();

	/**
	 * Returns a new object of class '<em>Large Icon Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Large Icon Type</em>'.
	 * @generated
	 */
	LargeIconType createLargeIconType();

	/**
	 * Returns a new object of class '<em>Listener Class</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Listener Class</em>'.
	 * @generated
	 */
	ListenerClass createListenerClass();

	/**
	 * Returns a new object of class '<em>Listener Class Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Listener Class Type</em>'.
	 * @generated
	 */
	ListenerClassType createListenerClassType();

	/**
	 * Returns a new object of class '<em>Listener Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Listener Type</em>'.
	 * @generated
	 */
	ListenerType createListenerType();

	/**
	 * Returns a new object of class '<em>Load On Startup Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Load On Startup Type</em>'.
	 * @generated
	 */
	LoadOnStartupType createLoadOnStartupType();

	/**
	 * Returns a new object of class '<em>Local Home Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Local Home Type</em>'.
	 * @generated
	 */
	LocalHomeType createLocalHomeType();

	/**
	 * Returns a new object of class '<em>Local Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Local Type</em>'.
	 * @generated
	 */
	LocalType createLocalType();

	/**
	 * Returns a new object of class '<em>Location Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Location Type</em>'.
	 * @generated
	 */
	LocationType createLocationType();

	/**
	 * Returns a new object of class '<em>Login Config Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Login Config Type</em>'.
	 * @generated
	 */
	LoginConfigType createLoginConfigType();

	/**
	 * Returns a new object of class '<em>Mime Mapping Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Mime Mapping Type</em>'.
	 * @generated
	 */
	MimeMappingType createMimeMappingType();

	/**
	 * Returns a new object of class '<em>Mime Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Mime Type Type</em>'.
	 * @generated
	 */
	MimeTypeType createMimeTypeType();

	/**
	 * Returns a new object of class '<em>Param Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Param Name Type</em>'.
	 * @generated
	 */
	ParamNameType createParamNameType();

	/**
	 * Returns a new object of class '<em>Param Value Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Param Value Type</em>'.
	 * @generated
	 */
	ParamValueType createParamValueType();

	/**
	 * Returns a new object of class '<em>Realm Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Realm Name Type</em>'.
	 * @generated
	 */
	RealmNameType createRealmNameType();

	/**
	 * Returns a new object of class '<em>Remote Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Remote Type</em>'.
	 * @generated
	 */
	RemoteType createRemoteType();

	/**
	 * Returns a new object of class '<em>Res Auth Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Res Auth Type</em>'.
	 * @generated
	 */
	ResAuthType createResAuthType();

	/**
	 * Returns a new object of class '<em>Resource Env Ref Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Resource Env Ref Name Type</em>'.
	 * @generated
	 */
	ResourceEnvRefNameType createResourceEnvRefNameType();

	/**
	 * Returns a new object of class '<em>Resource Env Ref Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Resource Env Ref Type</em>'.
	 * @generated
	 */
	ResourceEnvRefType createResourceEnvRefType();

	/**
	 * Returns a new object of class '<em>Resource Env Ref Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Resource Env Ref Type Type</em>'.
	 * @generated
	 */
	ResourceEnvRefTypeType createResourceEnvRefTypeType();

	/**
	 * Returns a new object of class '<em>Resource Ref Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Resource Ref Type</em>'.
	 * @generated
	 */
	ResourceRefType createResourceRefType();

	/**
	 * Returns a new object of class '<em>Res Ref Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Res Ref Name Type</em>'.
	 * @generated
	 */
	ResRefNameType createResRefNameType();

	/**
	 * Returns a new object of class '<em>Res Sharing Scope Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Res Sharing Scope Type</em>'.
	 * @generated
	 */
	ResSharingScopeType createResSharingScopeType();

	/**
	 * Returns a new object of class '<em>Res Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Res Type Type</em>'.
	 * @generated
	 */
	ResTypeType createResTypeType();

	/**
	 * Returns a new object of class '<em>Role Link Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Role Link Type</em>'.
	 * @generated
	 */
	RoleLinkType createRoleLinkType();

	/**
	 * Returns a new object of class '<em>Role Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Role Name Type</em>'.
	 * @generated
	 */
	RoleNameType createRoleNameType();

	/**
	 * Returns a new object of class '<em>Run As Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Run As Type</em>'.
	 * @generated
	 */
	RunAsType createRunAsType();

	/**
	 * Returns a new object of class '<em>Security Constraint Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Security Constraint Type</em>'.
	 * @generated
	 */
	SecurityConstraintType createSecurityConstraintType();

	/**
	 * Returns a new object of class '<em>Security Role Ref Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Security Role Ref Type</em>'.
	 * @generated
	 */
	SecurityRoleRefType createSecurityRoleRefType();

	/**
	 * Returns a new object of class '<em>Security Role Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Security Role Type</em>'.
	 * @generated
	 */
	SecurityRoleType createSecurityRoleType();

	/**
	 * Returns a new object of class '<em>Servlet Class Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Servlet Class Type</em>'.
	 * @generated
	 */
	ServletClassType createServletClassType();

	/**
	 * Returns a new object of class '<em>Servlet Mapping Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Servlet Mapping Type</em>'.
	 * @generated
	 */
	ServletMappingType createServletMappingType();

	/**
	 * Returns a new object of class '<em>Servlet Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Servlet Name Type</em>'.
	 * @generated
	 */
	ServletNameType createServletNameType();

	/**
	 * Returns a new object of class '<em>Servlet Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Servlet Type</em>'.
	 * @generated
	 */
	ServletType createServletType();

	/**
	 * Returns a new object of class '<em>Session Config Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Session Config Type</em>'.
	 * @generated
	 */
	SessionConfigType createSessionConfigType();

	/**
	 * Returns a new object of class '<em>Session Timeout Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Session Timeout Type</em>'.
	 * @generated
	 */
	SessionTimeoutType createSessionTimeoutType();

	/**
	 * Returns a new object of class '<em>Small Icon Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Small Icon Type</em>'.
	 * @generated
	 */
	SmallIconType createSmallIconType();

	/**
	 * Returns a new object of class '<em>Taglib Location Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Taglib Location Type</em>'.
	 * @generated
	 */
	TaglibLocationType createTaglibLocationType();

	/**
	 * Returns a new object of class '<em>Taglib Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Taglib Type</em>'.
	 * @generated
	 */
	TaglibType createTaglibType();

	/**
	 * Returns a new object of class '<em>Taglib Uri Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Taglib Uri Type</em>'.
	 * @generated
	 */
	TaglibUriType createTaglibUriType();

	/**
	 * Returns a new object of class '<em>Transport Guarantee Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Transport Guarantee Type</em>'.
	 * @generated
	 */
	TransportGuaranteeType createTransportGuaranteeType();

	/**
	 * Returns a new object of class '<em>Url Pattern Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Url Pattern Type</em>'.
	 * @generated
	 */
	UrlPatternType createUrlPatternType();

	/**
	 * Returns a new object of class '<em>User Data Constraint Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>User Data Constraint Type</em>'.
	 * @generated
	 */
	UserDataConstraintType createUserDataConstraintType();

	/**
	 * Returns a new object of class '<em>Web App Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Web App Type</em>'.
	 * @generated
	 */
	WebAppType createWebAppType();

	/**
	 * Returns a new object of class '<em>Web Resource Collection Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Web Resource Collection Type</em>'.
	 * @generated
	 */
	WebResourceCollectionType createWebResourceCollectionType();

	/**
	 * Returns a new object of class '<em>Web Resource Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Web Resource Name Type</em>'.
	 * @generated
	 */
	WebResourceNameType createWebResourceNameType();

	/**
	 * Returns a new object of class '<em>Welcome File List Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Welcome File List Type</em>'.
	 * @generated
	 */
	WelcomeFileListType createWelcomeFileListType();

	/**
	 * Returns a new object of class '<em>Welcome File Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Welcome File Type</em>'.
	 * @generated
	 */
	WelcomeFileType createWelcomeFileType();

	/**
	 * Returns the package supported by this factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the package supported by this factory.
	 * @generated
	 */
	Webapp23Package getWebapp23Package();

} //Webapp23Factory
