/**
 * 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.ejbjar.EjbJar31;

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.ejbjar.EjbJar31.EjbJar31Package
 * @generated
 */
public interface EjbJar31Factory extends EFactory {
	/**
	 * The singleton instance of the factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	EjbJar31Factory eINSTANCE = org.eclipse.modisco.jee.ejbjar.EjbJar31.impl.EjbJar31FactoryImpl.init();

	/**
	 * Returns a new object of class '<em>Access Timeout Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Access Timeout Type</em>'.
	 * @generated
	 */
	AccessTimeoutType createAccessTimeoutType();

	/**
	 * Returns a new object of class '<em>Activation Config Property Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Activation Config Property Type</em>'.
	 * @generated
	 */
	ActivationConfigPropertyType createActivationConfigPropertyType();

	/**
	 * Returns a new object of class '<em>Activation Config Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Activation Config Type</em>'.
	 * @generated
	 */
	ActivationConfigType createActivationConfigType();

	/**
	 * Returns a new object of class '<em>Addressing Responses Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Addressing Responses Type</em>'.
	 * @generated
	 */
	AddressingResponsesType createAddressingResponsesType();

	/**
	 * Returns a new object of class '<em>Addressing Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Addressing Type</em>'.
	 * @generated
	 */
	AddressingType createAddressingType();

	/**
	 * Returns a new object of class '<em>Application Exception Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Application Exception Type</em>'.
	 * @generated
	 */
	ApplicationExceptionType createApplicationExceptionType();

	/**
	 * Returns a new object of class '<em>Around Invoke Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Around Invoke Type</em>'.
	 * @generated
	 */
	AroundInvokeType createAroundInvokeType();

	/**
	 * Returns a new object of class '<em>Around Timeout Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Around Timeout Type</em>'.
	 * @generated
	 */
	AroundTimeoutType createAroundTimeoutType();

	/**
	 * Returns a new object of class '<em>Assembly Descriptor Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Assembly Descriptor Type</em>'.
	 * @generated
	 */
	AssemblyDescriptorType createAssemblyDescriptorType();

	/**
	 * Returns a new object of class '<em>Async Method Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Async Method Type</em>'.
	 * @generated
	 */
	AsyncMethodType createAsyncMethodType();

	/**
	 * Returns a new object of class '<em>Cmp Field Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Cmp Field Type</em>'.
	 * @generated
	 */
	CmpFieldType createCmpFieldType();

	/**
	 * Returns a new object of class '<em>Cmp Version Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Cmp Version Type</em>'.
	 * @generated
	 */
	CmpVersionType createCmpVersionType();

	/**
	 * Returns a new object of class '<em>Cmr Field Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Cmr Field Type</em>'.
	 * @generated
	 */
	CmrFieldType createCmrFieldType();

	/**
	 * Returns a new object of class '<em>Cmr Field Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Cmr Field Type Type</em>'.
	 * @generated
	 */
	CmrFieldTypeType createCmrFieldTypeType();

	/**
	 * Returns a new object of class '<em>Concurrency Management Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Concurrency Management Type Type</em>'.
	 * @generated
	 */
	ConcurrencyManagementTypeType createConcurrencyManagementTypeType();

	/**
	 * Returns a new object of class '<em>Concurrent Lock Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Concurrent Lock Type Type</em>'.
	 * @generated
	 */
	ConcurrentLockTypeType createConcurrentLockTypeType();

	/**
	 * Returns a new object of class '<em>Concurrent Method Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Concurrent Method Type</em>'.
	 * @generated
	 */
	ConcurrentMethodType createConcurrentMethodType();

	/**
	 * Returns a new object of class '<em>Container Transaction Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Container Transaction Type</em>'.
	 * @generated
	 */
	ContainerTransactionType createContainerTransactionType();

	/**
	 * Returns a new object of class '<em>Data Source Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Data Source Type</em>'.
	 * @generated
	 */
	DataSourceType createDataSourceType();

	/**
	 * Returns a new object of class '<em>Depends On Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Depends On Type</em>'.
	 * @generated
	 */
	DependsOnType createDependsOnType();

	/**
	 * 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>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 Class Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Ejb Class Type</em>'.
	 * @generated
	 */
	EjbClassType createEjbClassType();

	/**
	 * Returns a new object of class '<em>Ejb Jar Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Ejb Jar Type</em>'.
	 * @generated
	 */
	EjbJarType createEjbJarType();

	/**
	 * 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 Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Ejb Name Type</em>'.
	 * @generated
	 */
	EjbNameType createEjbNameType();

	/**
	 * 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>Ejb Relationship Role Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Ejb Relationship Role Type</em>'.
	 * @generated
	 */
	EjbRelationshipRoleType createEjbRelationshipRoleType();

	/**
	 * Returns a new object of class '<em>Ejb Relation Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Ejb Relation Type</em>'.
	 * @generated
	 */
	EjbRelationType createEjbRelationType();

	/**
	 * Returns a new object of class '<em>Empty Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Empty Type</em>'.
	 * @generated
	 */
	EmptyType createEmptyType();

	/**
	 * Returns a new object of class '<em>Enterprise Beans Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Enterprise Beans Type</em>'.
	 * @generated
	 */
	EnterpriseBeansType createEnterpriseBeansType();

	/**
	 * Returns a new object of class '<em>Entity Bean Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Entity Bean Type</em>'.
	 * @generated
	 */
	EntityBeanType createEntityBeanType();

	/**
	 * 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 Values Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Env Entry Type Values Type</em>'.
	 * @generated
	 */
	EnvEntryTypeValuesType createEnvEntryTypeValuesType();

	/**
	 * Returns a new object of class '<em>Exclude List Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Exclude List Type</em>'.
	 * @generated
	 */
	ExcludeListType createExcludeListType();

	/**
	 * Returns a new object of class '<em>Fully Qualified Class Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Fully Qualified Class Type</em>'.
	 * @generated
	 */
	FullyQualifiedClassType createFullyQualifiedClassType();

	/**
	 * Returns a new object of class '<em>Generic Boolean Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Generic Boolean Type</em>'.
	 * @generated
	 */
	GenericBooleanType createGenericBooleanType();

	/**
	 * Returns a new object of class '<em>Handler Chains Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Handler Chains Type</em>'.
	 * @generated
	 */
	HandlerChainsType createHandlerChainsType();

	/**
	 * Returns a new object of class '<em>Handler Chain Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Handler Chain Type</em>'.
	 * @generated
	 */
	HandlerChainType createHandlerChainType();

	/**
	 * Returns a new object of class '<em>Handler Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Handler Type</em>'.
	 * @generated
	 */
	HandlerType createHandlerType();

	/**
	 * 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>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 Method Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Init Method Type</em>'.
	 * @generated
	 */
	InitMethodType createInitMethodType();

	/**
	 * Returns a new object of class '<em>Injection Target Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Injection Target Type</em>'.
	 * @generated
	 */
	InjectionTargetType createInjectionTargetType();

	/**
	 * Returns a new object of class '<em>Interceptor Binding Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Interceptor Binding Type</em>'.
	 * @generated
	 */
	InterceptorBindingType createInterceptorBindingType();

	/**
	 * Returns a new object of class '<em>Interceptor Order Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Interceptor Order Type</em>'.
	 * @generated
	 */
	InterceptorOrderType createInterceptorOrderType();

	/**
	 * Returns a new object of class '<em>Interceptors Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Interceptors Type</em>'.
	 * @generated
	 */
	InterceptorsType createInterceptorsType();

	/**
	 * Returns a new object of class '<em>Interceptor Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Interceptor Type</em>'.
	 * @generated
	 */
	InterceptorType createInterceptorType();

	/**
	 * Returns a new object of class '<em>Java Identifier Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Java Identifier Type</em>'.
	 * @generated
	 */
	JavaIdentifierType createJavaIdentifierType();

	/**
	 * Returns a new object of class '<em>Java Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Java Type Type</em>'.
	 * @generated
	 */
	JavaTypeType createJavaTypeType();

	/**
	 * Returns a new object of class '<em>Jdbc Url Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Jdbc Url Type</em>'.
	 * @generated
	 */
	JdbcUrlType createJdbcUrlType();

	/**
	 * Returns a new object of class '<em>Jndi Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Jndi Name Type</em>'.
	 * @generated
	 */
	JndiNameType createJndiNameType();

	/**
	 * Returns a new object of class '<em>Lifecycle Callback Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Lifecycle Callback Type</em>'.
	 * @generated
	 */
	LifecycleCallbackType createLifecycleCallbackType();

	/**
	 * 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>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>Message Destination Link Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Message Destination Link Type</em>'.
	 * @generated
	 */
	MessageDestinationLinkType createMessageDestinationLinkType();

	/**
	 * Returns a new object of class '<em>Message Destination Ref Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Message Destination Ref Type</em>'.
	 * @generated
	 */
	MessageDestinationRefType createMessageDestinationRefType();

	/**
	 * Returns a new object of class '<em>Message Destination Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Message Destination Type</em>'.
	 * @generated
	 */
	MessageDestinationType createMessageDestinationType();

	/**
	 * Returns a new object of class '<em>Message Destination Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Message Destination Type Type</em>'.
	 * @generated
	 */
	MessageDestinationTypeType createMessageDestinationTypeType();

	/**
	 * Returns a new object of class '<em>Message Destination Usage Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Message Destination Usage Type</em>'.
	 * @generated
	 */
	MessageDestinationUsageType createMessageDestinationUsageType();

	/**
	 * Returns a new object of class '<em>Message Driven Bean Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Message Driven Bean Type</em>'.
	 * @generated
	 */
	MessageDrivenBeanType createMessageDrivenBeanType();

	/**
	 * Returns a new object of class '<em>Method Intf Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Method Intf Type</em>'.
	 * @generated
	 */
	MethodIntfType createMethodIntfType();

	/**
	 * Returns a new object of class '<em>Method Name Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Method Name Type</em>'.
	 * @generated
	 */
	MethodNameType createMethodNameType();

	/**
	 * Returns a new object of class '<em>Method Params Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Method Params Type</em>'.
	 * @generated
	 */
	MethodParamsType createMethodParamsType();

	/**
	 * Returns a new object of class '<em>Method Permission Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Method Permission Type</em>'.
	 * @generated
	 */
	MethodPermissionType createMethodPermissionType();

	/**
	 * Returns a new object of class '<em>Method Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Method Type</em>'.
	 * @generated
	 */
	MethodType createMethodType();

	/**
	 * Returns a new object of class '<em>Multiplicity Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Multiplicity Type</em>'.
	 * @generated
	 */
	MultiplicityType createMultiplicityType();

	/**
	 * Returns a new object of class '<em>Named Method Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Named Method Type</em>'.
	 * @generated
	 */
	NamedMethodType createNamedMethodType();

	/**
	 * 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>Path Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Path Type</em>'.
	 * @generated
	 */
	PathType createPathType();

	/**
	 * Returns a new object of class '<em>Persistence Context Ref Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Persistence Context Ref Type</em>'.
	 * @generated
	 */
	PersistenceContextRefType createPersistenceContextRefType();

	/**
	 * Returns a new object of class '<em>Persistence Context Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Persistence Context Type Type</em>'.
	 * @generated
	 */
	PersistenceContextTypeType createPersistenceContextTypeType();

	/**
	 * Returns a new object of class '<em>Persistence Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Persistence Type Type</em>'.
	 * @generated
	 */
	PersistenceTypeType createPersistenceTypeType();

	/**
	 * Returns a new object of class '<em>Persistence Unit Ref Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Persistence Unit Ref Type</em>'.
	 * @generated
	 */
	PersistenceUnitRefType createPersistenceUnitRefType();

	/**
	 * Returns a new object of class '<em>Port Component Ref Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Port Component Ref Type</em>'.
	 * @generated
	 */
	PortComponentRefType createPortComponentRefType();

	/**
	 * Returns a new object of class '<em>Property Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Property Type</em>'.
	 * @generated
	 */
	PropertyType createPropertyType();

	/**
	 * Returns a new object of class '<em>Query Method Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Query Method Type</em>'.
	 * @generated
	 */
	QueryMethodType createQueryMethodType();

	/**
	 * Returns a new object of class '<em>Query Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Query Type</em>'.
	 * @generated
	 */
	QueryType createQueryType();

	/**
	 * Returns a new object of class '<em>Relationship Role Source Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Relationship Role Source Type</em>'.
	 * @generated
	 */
	RelationshipRoleSourceType createRelationshipRoleSourceType();

	/**
	 * Returns a new object of class '<em>Relationships Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Relationships Type</em>'.
	 * @generated
	 */
	RelationshipsType createRelationshipsType();

	/**
	 * 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>Remove Method Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Remove Method Type</em>'.
	 * @generated
	 */
	RemoveMethodType createRemoveMethodType();

	/**
	 * 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 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 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>Respect Binding Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Respect Binding Type</em>'.
	 * @generated
	 */
	RespectBindingType createRespectBindingType();

	/**
	 * 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>Result Type Mapping Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Result Type Mapping Type</em>'.
	 * @generated
	 */
	ResultTypeMappingType createResultTypeMappingType();

	/**
	 * 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 Identity Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Security Identity Type</em>'.
	 * @generated
	 */
	SecurityIdentityType createSecurityIdentityType();

	/**
	 * 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>Service Ref Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Service Ref Type</em>'.
	 * @generated
	 */
	ServiceRefType createServiceRefType();

	/**
	 * Returns a new object of class '<em>Session Bean Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Session Bean Type</em>'.
	 * @generated
	 */
	SessionBeanType createSessionBeanType();

	/**
	 * Returns a new object of class '<em>Session Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Session Type Type</em>'.
	 * @generated
	 */
	SessionTypeType createSessionTypeType();

	/**
	 * Returns a new object of class '<em>Stateful Timeout Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Stateful Timeout Type</em>'.
	 * @generated
	 */
	StatefulTimeoutType createStatefulTimeoutType();

	/**
	 * Returns a new object of class '<em>String</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>String</em>'.
	 * @generated
	 */
	String createString();

	/**
	 * Returns a new object of class '<em>Timer Schedule Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Timer Schedule Type</em>'.
	 * @generated
	 */
	TimerScheduleType createTimerScheduleType();

	/**
	 * Returns a new object of class '<em>Timer Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Timer Type</em>'.
	 * @generated
	 */
	TimerType createTimerType();

	/**
	 * Returns a new object of class '<em>Time Unit Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Time Unit Type Type</em>'.
	 * @generated
	 */
	TimeUnitTypeType createTimeUnitTypeType();

	/**
	 * Returns a new object of class '<em>Transaction Type Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Transaction Type Type</em>'.
	 * @generated
	 */
	TransactionTypeType createTransactionTypeType();

	/**
	 * Returns a new object of class '<em>Trans Attribute Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Trans Attribute Type</em>'.
	 * @generated
	 */
	TransAttributeType createTransAttributeType();

	/**
	 * Returns a new object of class '<em>True False Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>True False Type</em>'.
	 * @generated
	 */
	TrueFalseType createTrueFalseType();

	/**
	 * 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>Xsd Any URI Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Xsd Any URI Type</em>'.
	 * @generated
	 */
	XsdAnyURIType createXsdAnyURIType();

	/**
	 * Returns a new object of class '<em>Xsd Boolean Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Xsd Boolean Type</em>'.
	 * @generated
	 */
	XsdBooleanType createXsdBooleanType();

	/**
	 * Returns a new object of class '<em>Xsd Integer Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Xsd Integer Type</em>'.
	 * @generated
	 */
	XsdIntegerType createXsdIntegerType();

	/**
	 * Returns a new object of class '<em>Xsd NMTOKEN Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Xsd NMTOKEN Type</em>'.
	 * @generated
	 */
	XsdNMTOKENType createXsdNMTOKENType();

	/**
	 * Returns a new object of class '<em>Xsd Non Negative Integer Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Xsd Non Negative Integer Type</em>'.
	 * @generated
	 */
	XsdNonNegativeIntegerType createXsdNonNegativeIntegerType();

	/**
	 * Returns a new object of class '<em>Xsd Positive Integer Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Xsd Positive Integer Type</em>'.
	 * @generated
	 */
	XsdPositiveIntegerType createXsdPositiveIntegerType();

	/**
	 * Returns a new object of class '<em>Xsd QName Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Xsd QName Type</em>'.
	 * @generated
	 */
	XsdQNameType createXsdQNameType();

	/**
	 * Returns a new object of class '<em>Xsd String Type</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Xsd String Type</em>'.
	 * @generated
	 */
	XsdStringType createXsdStringType();

	/**
	 * Returns the package supported by this factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the package supported by this factory.
	 * @generated
	 */
	EjbJar31Package getEjbJar31Package();

} //EjbJar31Factory
