Copyright (c) 2000, 2019 IBM Corporation and others.
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
Contributors:
    IBM Corporation - initial API and implementation
    IBM Corporation - added J2SE 1.5 support
/*******************************************************************************
 * Copyright (c) 2000, 2019 IBM Corporation and others.
 *
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     IBM Corporation - added J2SE 1.5 support
 *******************************************************************************/
package org.eclipse.jdt.core;

import java.io.InputStream;

import org.eclipse.core.runtime.IProgressMonitor;

Represents either a source type in a compilation unit (either a top-level
type, a member type, a local type, an anonymous type or a lambda expression)
or a binary type in a class file. Enumeration classes and annotation
types are subkinds of classes and interfaces, respectively.

Note that the element name of an anonymous source type and lambda expressions
is always empty. Types representing lambda expressions are pseudo-elements 
and not included in the children of their parent. Lambda expressions are created 
as the result of a ICodeAssist.codeSelect(...). For more information 
on such pseudo-elements, see ILocalVariable.

If a binary type cannot be parsed, its structure remains unknown.
Use IJavaElement.isStructureKnown to determine whether this
is the case.


The children are of type IMember, which includes IField,
IMethod, IInitializer and IType.
The children are listed in the order in which they appear in the source or class file.

 Caveat: The children of a binary type include nested types. However, the parent of such a nested binary type is not the enclosing type, but that nested type's IClassFile! 
@noimplement
This interface is not intended to be implemented by clients./**
 * Represents either a source type in a compilation unit (either a top-level
 * type, a member type, a local type, an anonymous type or a lambda expression)
 * or a binary type in a class file. Enumeration classes and annotation
 * types are subkinds of classes and interfaces, respectively.
 * <p>
 * Note that the element name of an anonymous source type and lambda expressions
 * is always empty. Types representing lambda expressions are pseudo-elements 
 * and not included in the children of their parent. Lambda expressions are created 
 * as the result of a <code>ICodeAssist.codeSelect(...)</code>. For more information 
 * on such pseudo-elements, see <code>ILocalVariable</code>.
 * </p><p>
 * If a binary type cannot be parsed, its structure remains unknown.
 * Use <code>IJavaElement.isStructureKnown</code> to determine whether this
 * is the case.
 * </p>
 * <p>
 * The children are of type <code>IMember</code>, which includes <code>IField</code>,
 * <code>IMethod</code>, <code>IInitializer</code> and <code>IType</code>.
 * The children are listed in the order in which they appear in the source or class file.
 * </p>
 * <p>
 * Caveat: The {@link #getChildren() children} of a {@link #isBinary() binary} type include
 * nested types. However, the {@link #getParent() parent} of such a nested binary type is
 * <em>not</em> the enclosing type, but that nested type's {@link IClassFile}!
 * </p>
 *
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IType extends IMember, IAnnotatable {
	
Do code completion inside a code snippet in the context of the current type.
If the type has access to its source code and the insertion position is valid,
then completion is performed against the source. Otherwise the completion is performed
against the type structure and the given locals variables.
Params:
snippet – the code snippet
insertion – the position with in source where the snippet
is inserted. This position must not be in comments.
A possible value is -1, if the position is not known.
position – the position within snippet where the user
is performing code assist.
localVariableTypeNames – an array (possibly empty) of fully qualified
type names of local variables visible at the current scope
localVariableNames – an array (possibly empty) of local variable names
that are visible at the current scope
localVariableModifiers – an array (possible empty) of modifiers for
local variables
isStatic – whether the current scope is in a static context
requestor – the completion requestor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Since:
2.0
Deprecated:
Use codeComplete(char[], int, int, char[][], char[][], int[], boolean, CompletionRequestor) instead./**
	 * Do code completion inside a code snippet in the context of the current type.
	 *
	 * If the type has access to its source code and the insertion position is valid,
	 * then completion is performed against the source. Otherwise the completion is performed
	 * against the type structure and the given locals variables.
	 *
	 * @param snippet the code snippet
	 * @param insertion the position with in source where the snippet
	 * is inserted. This position must not be in comments.
	 * A possible value is -1, if the position is not known.
	 * @param position the position within snippet where the user
	 * is performing code assist.
	 * @param localVariableTypeNames an array (possibly empty) of fully qualified
	 * type names of local variables visible at the current scope
	 * @param localVariableNames an array (possibly empty) of local variable names
	 * that are visible at the current scope
	 * @param localVariableModifiers an array (possible empty) of modifiers for
	 * local variables
	 * @param isStatic whether the current scope is in a static context
	 * @param requestor the completion requestor
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 2.0
	 * @deprecated Use {@link #codeComplete(char[],int,int,char[][],char[][],int[],boolean,CompletionRequestor)} instead.
	 */
	void codeComplete(
		char[] snippet,
		int insertion,
		int position,
		char[][] localVariableTypeNames,
		char[][] localVariableNames,
		int[] localVariableModifiers,
		boolean isStatic,
		ICompletionRequestor requestor)
		throws JavaModelException;

	
Do code completion inside a code snippet in the context of the current type.
It considers types in the working copies with the given owner first. In other words,
the owner's working copies will take precedence over their original compilation units
in the workspace.

Note that if a working copy is empty, it will be as if the original compilation
unit had been deleted.

If the type has access to its source code and the insertion position is valid,
then completion is performed against the source. Otherwise the completion is performed
against the type structure and the given locals variables.

Params:
snippet – the code snippet
insertion – the position with in source where the snippet
is inserted. This position must not be in comments.
A possible value is -1, if the position is not known.
position – the position with in snippet where the user
is performing code assist.
localVariableTypeNames – an array (possibly empty) of fully qualified
type names of local variables visible at the current scope
localVariableNames – an array (possibly empty) of local variable names
that are visible at the current scope
localVariableModifiers – an array (possible empty) of modifiers for
local variables
isStatic – whether the current scope is in a static context
requestor – the completion requestor
owner – the owner of working copies that take precedence over their original compilation units
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Since:
3.0
Deprecated:
Use codeComplete(char[], int, int, char[][], char[][], int[], boolean, CompletionRequestor, WorkingCopyOwner) instead./**
	 * Do code completion inside a code snippet in the context of the current type.
	 * It considers types in the working copies with the given owner first. In other words,
	 * the owner's working copies will take precedence over their original compilation units
	 * in the workspace.
	 * <p>
	 * Note that if a working copy is empty, it will be as if the original compilation
	 * unit had been deleted.
	 * </p><p>
	 * If the type has access to its source code and the insertion position is valid,
	 * then completion is performed against the source. Otherwise the completion is performed
	 * against the type structure and the given locals variables.
	 * </p>
	 *
	 * @param snippet the code snippet
	 * @param insertion the position with in source where the snippet
	 * is inserted. This position must not be in comments.
	 * A possible value is -1, if the position is not known.
	 * @param position the position with in snippet where the user
	 * is performing code assist.
	 * @param localVariableTypeNames an array (possibly empty) of fully qualified
	 * type names of local variables visible at the current scope
	 * @param localVariableNames an array (possibly empty) of local variable names
	 * that are visible at the current scope
	 * @param localVariableModifiers an array (possible empty) of modifiers for
	 * local variables
	 * @param isStatic whether the current scope is in a static context
	 * @param requestor the completion requestor
	 * @param owner the owner of working copies that take precedence over their original compilation units
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 3.0
	 * @deprecated Use {@link #codeComplete(char[],int,int,char[][],char[][],int[],boolean,CompletionRequestor,WorkingCopyOwner)} instead.
	 */
	void codeComplete(
		char[] snippet,
		int insertion,
		int position,
		char[][] localVariableTypeNames,
		char[][] localVariableNames,
		int[] localVariableModifiers,
		boolean isStatic,
		ICompletionRequestor requestor,
		WorkingCopyOwner owner)
		throws JavaModelException;

	
Do code completion inside a code snippet in the context of the current type.
If the type has access to its source code and the insertion position is valid,
then completion is performed against the source. Otherwise the completion is performed
against the type structure and the given locals variables.
Params:
snippet – the code snippet
insertion – the position with in source where the snippet
is inserted. This position must not be in comments.
A possible value is -1, if the position is not known.
position – the position within snippet where the user
is performing code assist.
localVariableTypeNames – an array (possibly empty) of fully qualified
type names of local variables visible at the current scope
localVariableNames – an array (possibly empty) of local variable names
that are visible at the current scope
localVariableModifiers – an array (possible empty) of modifiers for
local variables
isStatic – whether the current scope is in a static context
requestor – the completion requestor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Since:
3.1/**
	 * Do code completion inside a code snippet in the context of the current type.
	 *
	 * If the type has access to its source code and the insertion position is valid,
	 * then completion is performed against the source. Otherwise the completion is performed
	 * against the type structure and the given locals variables.
	 *
	 * @param snippet the code snippet
	 * @param insertion the position with in source where the snippet
	 * is inserted. This position must not be in comments.
	 * A possible value is -1, if the position is not known.
	 * @param position the position within snippet where the user
	 * is performing code assist.
	 * @param localVariableTypeNames an array (possibly empty) of fully qualified
	 * type names of local variables visible at the current scope
	 * @param localVariableNames an array (possibly empty) of local variable names
	 * that are visible at the current scope
	 * @param localVariableModifiers an array (possible empty) of modifiers for
	 * local variables
	 * @param isStatic whether the current scope is in a static context
	 * @param requestor the completion requestor
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 3.1
	 */
	void codeComplete(
		char[] snippet,
		int insertion,
		int position,
		char[][] localVariableTypeNames,
		char[][] localVariableNames,
		int[] localVariableModifiers,
		boolean isStatic,
		CompletionRequestor requestor)
		throws JavaModelException;
	
	
Do code completion inside a code snippet in the context of the current type.
If the type has access to its source code and the insertion position is valid,
then completion is performed against the source. Otherwise the completion is performed
against the type structure and the given locals variables.
 If IProgressMonitor is not null then some proposals which can be very long to compute are proposed. To avoid that the code assist operation take too much time a IProgressMonitor which automatically cancel the code assist operation when a specified amount of time is reached could be used. 
new IProgressMonitor() {
    private final static int TIMEOUT = 500; //ms
    private long endTime;
    public void beginTask(String name, int totalWork) {
        fEndTime= System.currentTimeMillis() + TIMEOUT;
    }
    public boolean isCanceled() {
        return endTime <= System.currentTimeMillis();
    }
    ...
};


Params:
snippet – the code snippet
insertion – the position with in source where the snippet
is inserted. This position must not be in comments.
A possible value is -1, if the position is not known.
position – the position within snippet where the user
is performing code assist.
localVariableTypeNames – an array (possibly empty) of fully qualified
type names of local variables visible at the current scope
localVariableNames – an array (possibly empty) of local variable names
that are visible at the current scope
localVariableModifiers – an array (possible empty) of modifiers for
local variables
isStatic – whether the current scope is in a static context
requestor – the completion requestor
monitor – the progress monitor used to report progress
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Since:
3.5/**
	 * Do code completion inside a code snippet in the context of the current type.
	 *
	 * If the type has access to its source code and the insertion position is valid,
	 * then completion is performed against the source. Otherwise the completion is performed
	 * against the type structure and the given locals variables.
	 * <p>
	 * If {@link IProgressMonitor} is not <code>null</code> then some proposals which
	 * can be very long to compute are proposed. To avoid that the code assist operation
	 * take too much time a {@link IProgressMonitor} which automatically cancel the code
	 * assist operation when a specified amount of time is reached could be used.
	 * 
	 * <pre>
	 * new IProgressMonitor() {
	 *     private final static int TIMEOUT = 500; //ms
	 *     private long endTime;
	 *     public void beginTask(String name, int totalWork) {
	 *         fEndTime= System.currentTimeMillis() + TIMEOUT;
	 *     }
	 *     public boolean isCanceled() {
	 *         return endTime <= System.currentTimeMillis();
	 *     }
	 *     ...
	 * };
	 * </pre>
	 * <p>
	 *
	 * @param snippet the code snippet
	 * @param insertion the position with in source where the snippet
	 * is inserted. This position must not be in comments.
	 * A possible value is -1, if the position is not known.
	 * @param position the position within snippet where the user
	 * is performing code assist.
	 * @param localVariableTypeNames an array (possibly empty) of fully qualified
	 * type names of local variables visible at the current scope
	 * @param localVariableNames an array (possibly empty) of local variable names
	 * that are visible at the current scope
	 * @param localVariableModifiers an array (possible empty) of modifiers for
	 * local variables
	 * @param isStatic whether the current scope is in a static context
	 * @param requestor the completion requestor
	 * @param monitor the progress monitor used to report progress
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 3.5
	 */
	void codeComplete(
		char[] snippet,
		int insertion,
		int position,
		char[][] localVariableTypeNames,
		char[][] localVariableNames,
		int[] localVariableModifiers,
		boolean isStatic,
		CompletionRequestor requestor,
		IProgressMonitor monitor)
		throws JavaModelException;

	
Do code completion inside a code snippet in the context of the current type.
It considers types in the working copies with the given owner first. In other words,
the owner's working copies will take precedence over their original compilation units
in the workspace.

Note that if a working copy is empty, it will be as if the original compilation
unit had been deleted.

If the type has access to its source code and the insertion position is valid,
then completion is performed against the source. Otherwise the completion is performed
against the type structure and the given locals variables.

Params:
snippet – the code snippet
insertion – the position with in source where the snippet
is inserted. This position must not be in comments.
A possible value is -1, if the position is not known.
position – the position with in snippet where the user
is performing code assist.
localVariableTypeNames – an array (possibly empty) of fully qualified
type names of local variables visible at the current scope
localVariableNames – an array (possibly empty) of local variable names
that are visible at the current scope
localVariableModifiers – an array (possible empty) of modifiers for
local variables
isStatic – whether the current scope is in a static context
requestor – the completion requestor
owner – the owner of working copies that take precedence over their original compilation units
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Since:
3.1/**
	 * Do code completion inside a code snippet in the context of the current type.
	 * It considers types in the working copies with the given owner first. In other words,
	 * the owner's working copies will take precedence over their original compilation units
	 * in the workspace.
	 * <p>
	 * Note that if a working copy is empty, it will be as if the original compilation
	 * unit had been deleted.
	 * </p><p>
	 * If the type has access to its source code and the insertion position is valid,
	 * then completion is performed against the source. Otherwise the completion is performed
	 * against the type structure and the given locals variables.
	 * </p>
	 *
	 * @param snippet the code snippet
	 * @param insertion the position with in source where the snippet
	 * is inserted. This position must not be in comments.
	 * A possible value is -1, if the position is not known.
	 * @param position the position with in snippet where the user
	 * is performing code assist.
	 * @param localVariableTypeNames an array (possibly empty) of fully qualified
	 * type names of local variables visible at the current scope
	 * @param localVariableNames an array (possibly empty) of local variable names
	 * that are visible at the current scope
	 * @param localVariableModifiers an array (possible empty) of modifiers for
	 * local variables
	 * @param isStatic whether the current scope is in a static context
	 * @param requestor the completion requestor
	 * @param owner the owner of working copies that take precedence over their original compilation units
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 3.1
	 */
	void codeComplete(
		char[] snippet,
		int insertion,
		int position,
		char[][] localVariableTypeNames,
		char[][] localVariableNames,
		int[] localVariableModifiers,
		boolean isStatic,
		CompletionRequestor requestor,
		WorkingCopyOwner owner)
		throws JavaModelException;
	
	
Do code completion inside a code snippet in the context of the current type.
It considers types in the working copies with the given owner first. In other words,
the owner's working copies will take precedence over their original compilation units
in the workspace.

Note that if a working copy is empty, it will be as if the original compilation
unit had been deleted.

If the type has access to its source code and the insertion position is valid,
then completion is performed against the source. Otherwise the completion is performed
against the type structure and the given locals variables.

 If IProgressMonitor is not null then some proposals which can be very long to compute are proposed. To avoid that the code assist operation take too much time a IProgressMonitor which automatically cancel the code assist operation when a specified amount of time is reached could be used. 
new IProgressMonitor() {
    private final static int TIMEOUT = 500; //ms
    private long endTime;
    public void beginTask(String name, int totalWork) {
        endTime= System.currentTimeMillis() + TIMEOUT;
    }
    public boolean isCanceled() {
        return endTime <= System.currentTimeMillis();
    }
    ...
};


Params:
snippet – the code snippet
insertion – the position with in source where the snippet
is inserted. This position must not be in comments.
A possible value is -1, if the position is not known.
position – the position with in snippet where the user
is performing code assist.
localVariableTypeNames – an array (possibly empty) of fully qualified
type names of local variables visible at the current scope
localVariableNames – an array (possibly empty) of local variable names
that are visible at the current scope
localVariableModifiers – an array (possible empty) of modifiers for
local variables
isStatic – whether the current scope is in a static context
requestor – the completion requestor
owner – the owner of working copies that take precedence over their original compilation units
monitor – the progress monitor used to report progress
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Since:
3.5/**
	 * Do code completion inside a code snippet in the context of the current type.
	 * It considers types in the working copies with the given owner first. In other words,
	 * the owner's working copies will take precedence over their original compilation units
	 * in the workspace.
	 * <p>
	 * Note that if a working copy is empty, it will be as if the original compilation
	 * unit had been deleted.
	 * </p><p>
	 * If the type has access to its source code and the insertion position is valid,
	 * then completion is performed against the source. Otherwise the completion is performed
	 * against the type structure and the given locals variables.
	 * </p>
	 * <p>
	 * If {@link IProgressMonitor} is not <code>null</code> then some proposals which
	 * can be very long to compute are proposed. To avoid that the code assist operation
	 * take too much time a {@link IProgressMonitor} which automatically cancel the code
	 * assist operation when a specified amount of time is reached could be used.
	 * 
	 * <pre>
	 * new IProgressMonitor() {
	 *     private final static int TIMEOUT = 500; //ms
	 *     private long endTime;
	 *     public void beginTask(String name, int totalWork) {
	 *         endTime= System.currentTimeMillis() + TIMEOUT;
	 *     }
	 *     public boolean isCanceled() {
	 *         return endTime <= System.currentTimeMillis();
	 *     }
	 *     ...
	 * };
	 * </pre>
	 * <p>
	 *
	 * @param snippet the code snippet
	 * @param insertion the position with in source where the snippet
	 * is inserted. This position must not be in comments.
	 * A possible value is -1, if the position is not known.
	 * @param position the position with in snippet where the user
	 * is performing code assist.
	 * @param localVariableTypeNames an array (possibly empty) of fully qualified
	 * type names of local variables visible at the current scope
	 * @param localVariableNames an array (possibly empty) of local variable names
	 * that are visible at the current scope
	 * @param localVariableModifiers an array (possible empty) of modifiers for
	 * local variables
	 * @param isStatic whether the current scope is in a static context
	 * @param requestor the completion requestor
	 * @param owner the owner of working copies that take precedence over their original compilation units
	 * @param monitor the progress monitor used to report progress
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 3.5
	 */
	void codeComplete(
		char[] snippet,
		int insertion,
		int position,
		char[][] localVariableTypeNames,
		char[][] localVariableNames,
		int[] localVariableModifiers,
		boolean isStatic,
		CompletionRequestor requestor,
		WorkingCopyOwner owner,
		IProgressMonitor monitor)
		throws JavaModelException;


	
Creates and returns a field in this type with the
given contents.

Optionally, the new element can be positioned before the specified
sibling. If no sibling is specified, the element will be inserted
as the last field declaration in this type.
It is possible that a field with the same name already exists in this type.
The value of the force parameter affects the resolution of
such a conflict:

 true - in this case the field is created with the new contents
 false - in this case a JavaModelException is thrown

Params:
contents – the given contents
sibling – the given sibling
force – a flag in case the same name already exists in this type
monitor – the given progress monitor
Throws:
JavaModelException – if the element could not be created. Reasons include:

 This Java element does not exist (ELEMENT_DOES_NOT_EXIST)
 A CoreException occurred while updating an underlying resource
 The specified sibling is not a child of this type (INVALID_SIBLING)
 The contents could not be recognized as a field declaration (INVALID_CONTENTS)
 This type is read-only (binary) (READ_ONLY)
 There was a naming collision with an existing field (NAME_COLLISION)
Returns:
a field in this type with the given contents/**
	 * Creates and returns a field in this type with the
	 * given contents.
	 * <p>
	 * Optionally, the new element can be positioned before the specified
	 * sibling. If no sibling is specified, the element will be inserted
	 * as the last field declaration in this type.</p>
	 *
	 * <p>It is possible that a field with the same name already exists in this type.
	 * The value of the <code>force</code> parameter affects the resolution of
	 * such a conflict:
	 * <ul>
	 * <li> <code>true</code> - in this case the field is created with the new contents</li>
	 * <li> <code>false</code> - in this case a <code>JavaModelException</code> is thrown</li>
	 * </ul>
	 *
	 * @param contents the given contents
	 * @param sibling the given sibling
	 * @param force a flag in case the same name already exists in this type
	 * @param monitor the given progress monitor
	 * @exception JavaModelException if the element could not be created. Reasons include:
	 * <ul>
	 * <li> This Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
	 * <li> A <code>CoreException</code> occurred while updating an underlying resource
	 * <li> The specified sibling is not a child of this type (INVALID_SIBLING)
	 * <li> The contents could not be recognized as a field declaration (INVALID_CONTENTS)
	 * <li> This type is read-only (binary) (READ_ONLY)
	 * <li> There was a naming collision with an existing field (NAME_COLLISION)
	 * </ul>
	 * @return a field in this type with the given contents
	 */
	IField createField(String contents, IJavaElement sibling, boolean force, IProgressMonitor monitor)
		throws JavaModelException;

	
Creates and returns a static initializer in this type with the
given contents.

Optionally, the new element can be positioned before the specified
sibling. If no sibling is specified, the new initializer is positioned
after the last existing initializer declaration, or as the first member
in the type if there are no initializers.
Params:
contents – the given contents
sibling – the given sibling
monitor – the given progress monitor
Throws:
JavaModelException – if the element could not be created. Reasons include:

 This element does not exist
 A CoreException occurred while updating an underlying resource
 The specified sibling is not a child of this type (INVALID_SIBLING)
 The contents could not be recognized as an initializer declaration (INVALID_CONTENTS)
 This type is read-only (binary) (READ_ONLY)
Returns:
a static initializer in this type with the given contents/**
	 * Creates and returns a static initializer in this type with the
	 * given contents.
	 * <p>
	 * Optionally, the new element can be positioned before the specified
	 * sibling. If no sibling is specified, the new initializer is positioned
	 * after the last existing initializer declaration, or as the first member
	 * in the type if there are no initializers.</p>
	 *
	 * @param contents the given contents
	 * @param sibling the given sibling
	 * @param monitor the given progress monitor
	 * @exception JavaModelException if the element could not be created. Reasons include:
	 * <ul>
	 * <li> This element does not exist
	 * <li> A <code>CoreException</code> occurred while updating an underlying resource
	 * <li> The specified sibling is not a child of this type (INVALID_SIBLING)
	 * <li> The contents could not be recognized as an initializer declaration (INVALID_CONTENTS)
	 * <li> This type is read-only (binary) (READ_ONLY)
	 * </ul>
	 * @return a static initializer in this type with the given contents
	 */
	IInitializer createInitializer(String contents, IJavaElement sibling, IProgressMonitor monitor)
		throws JavaModelException;

	
Creates and returns a method or constructor in this type with the
given contents.

Optionally, the new element can be positioned before the specified
sibling. If no sibling is specified, the element will be appended
to this type.
It is possible that a method with the same signature already exists in this type.
The value of the force parameter affects the resolution of
such a conflict:

 true - in this case the method is created with the new contents
 false - in this case a JavaModelException is thrown

Params:
contents – the given contents
sibling – the given sibling
force – a flag in case the same name already exists in this type
monitor – the given progress monitor
Throws:
JavaModelException – if the element could not be created. Reasons include:

 This Java element does not exist (ELEMENT_DOES_NOT_EXIST)
 A CoreException occurred while updating an underlying resource
 The specified sibling is not a child of this type (INVALID_SIBLING)
 The contents could not be recognized as a method or constructor
	declaration (INVALID_CONTENTS)
 This type is read-only (binary) (READ_ONLY)
 There was a naming collision with an existing method (NAME_COLLISION)
Returns:
a method or constructor in this type with the given contents/**
	 * Creates and returns a method or constructor in this type with the
	 * given contents.
	 * <p>
	 * Optionally, the new element can be positioned before the specified
	 * sibling. If no sibling is specified, the element will be appended
	 * to this type.
	 *
	 * <p>It is possible that a method with the same signature already exists in this type.
	 * The value of the <code>force</code> parameter affects the resolution of
	 * such a conflict:
	 * <ul>
	 * <li> <code>true</code> - in this case the method is created with the new contents</li>
	 * <li> <code>false</code> - in this case a <code>JavaModelException</code> is thrown</li>
	 * </ul>
	 *
	 * @param contents the given contents
	 * @param sibling the given sibling
	 * @param force a flag in case the same name already exists in this type
	 * @param monitor the given progress monitor
	 * @exception JavaModelException if the element could not be created. Reasons include:
	 * <ul>
	 * <li> This Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
	 * <li> A <code>CoreException</code> occurred while updating an underlying resource
	 * <li> The specified sibling is not a child of this type (INVALID_SIBLING)
	 * <li> The contents could not be recognized as a method or constructor
	 *		declaration (INVALID_CONTENTS)
	 * <li> This type is read-only (binary) (READ_ONLY)
	 * <li> There was a naming collision with an existing method (NAME_COLLISION)
	 * </ul>
	 * @return a method or constructor in this type with the given contents
	 */
	IMethod createMethod(String contents, IJavaElement sibling, boolean force, IProgressMonitor monitor)
		throws JavaModelException;

	
Creates and returns a type in this type with the
given contents.

Optionally, the new type can be positioned before the specified
sibling. If no sibling is specified, the type will be appended
to this type.
It is possible that a type with the same name already exists in this type.
The value of the force parameter affects the resolution of
such a conflict:

 true - in this case the type is created with the new contents
 false - in this case a JavaModelException is thrown

Params:
contents – the given contents
sibling – the given sibling
force – a flag in case the same name already exists in this type
monitor – the given progress monitor
Throws:
JavaModelException – if the element could not be created. Reasons include:

 This Java element does not exist (ELEMENT_DOES_NOT_EXIST)
 A CoreException occurred while updating an underlying resource
 The specified sibling is not a child of this type (INVALID_SIBLING)
 The contents could not be recognized as a type declaration (INVALID_CONTENTS)
 This type is read-only (binary) (READ_ONLY)
 There was a naming collision with an existing field (NAME_COLLISION)
Returns:
a type in this type with the given contents/**
	 * Creates and returns a type in this type with the
	 * given contents.
	 * <p>
	 * Optionally, the new type can be positioned before the specified
	 * sibling. If no sibling is specified, the type will be appended
	 * to this type.</p>
	 *
	 * <p>It is possible that a type with the same name already exists in this type.
	 * The value of the <code>force</code> parameter affects the resolution of
	 * such a conflict:
	 * <ul>
	 * <li> <code>true</code> - in this case the type is created with the new contents</li>
	 * <li> <code>false</code> - in this case a <code>JavaModelException</code> is thrown</li>
	 * </ul>
	 *
	 * @param contents the given contents
	 * @param sibling the given sibling
	 * @param force a flag in case the same name already exists in this type
	 * @param monitor the given progress monitor
	 * @exception JavaModelException if the element could not be created. Reasons include:
	 * <ul>
	 * <li> This Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
	 * <li> A <code>CoreException</code> occurred while updating an underlying resource
	 * <li> The specified sibling is not a child of this type (INVALID_SIBLING)
	 * <li> The contents could not be recognized as a type declaration (INVALID_CONTENTS)
	 * <li> This type is read-only (binary) (READ_ONLY)
	 * <li> There was a naming collision with an existing field (NAME_COLLISION)
	 * </ul>
	 * @return a type in this type with the given contents
	 */
	IType createType(String contents, IJavaElement sibling, boolean force, IProgressMonitor monitor)
		throws JavaModelException;

	
Finds the methods in this type that correspond to
the given method.
A method m1 corresponds to another method m2 if:

m1 has the same element name as m2.
m1 has the same number of arguments as m2 and
    the simple names of the argument types must be equals.
m1 exists.

Params:
method – the given method
Returns:
the found method or null if no such methods can be found.
Since:
2.0/**
	 * Finds the methods in this type that correspond to
	 * the given method.
	 * A method m1 corresponds to another method m2 if:
	 * <ul>
	 * <li>m1 has the same element name as m2.
	 * <li>m1 has the same number of arguments as m2 and
	 *     the simple names of the argument types must be equals.
	 * <li>m1 exists.
	 * </ul>
	 * @param method the given method
	 * @return the found method or <code>null</code> if no such methods can be found.
	 *
	 * @since 2.0
	 */
	IMethod[] findMethods(IMethod method);

	
Returns the children of this type that have the given category as a @category tag.
Returns an empty array if no children with this category exist.

The results are listed in the order in which they appear in the source or class file.

Throws:
JavaModelException – if this element does not exist or if an
     exception occurs while accessing its corresponding resource.
 @since 3.2
Returns:
the children for the given category./**
	 * Returns the children of this type that have the given category as a <code>@category</code> tag.
	 * Returns an empty array if no children with this category exist.
	 *
	 * <p>
	 * The results are listed in the order in which they appear in the source or class file.
	 * </p>
	 * 
	 * @return the children for the given category.
	 * @exception JavaModelException if this element does not exist or if an
	 *      exception occurs while accessing its corresponding resource.
	 *  @since 3.2
	 */
	IJavaElement[] getChildrenForCategory(String category) throws JavaModelException;

	
Returns the simple name of this type, unqualified by package or enclosing type.
This is a handle-only method.
Note that the element name of an anonymous source type and lambda expressions
is always empty.
Returns:
the simple name of this type/**
	 * Returns the simple name of this type, unqualified by package or enclosing type.
	 * This is a handle-only method.
	 * 
	 * Note that the element name of an anonymous source type and lambda expressions
	 * is always empty.
	 *
	 * @return the simple name of this type
	 */
	@Override
	String getElementName();

	
Returns the field with the specified name
in this type (for example, "bar").
This is a handle-only method.  The field may or may not exist.
Params:
name – the given name
Returns:
the field with the specified name in this type/**
	 * Returns the field with the specified name
	 * in this type (for example, <code>"bar"</code>).
	 * This is a handle-only method.  The field may or may not exist.
	 *
	 * @param name the given name
	 * @return the field with the specified name in this type
	 */
	IField getField(String name);

	
Returns the fields declared by this type in the order in which they appear 
in the source or class file. For binary types, this includes synthetic fields.
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
the fields declared by this type/**
	 * Returns the fields declared by this type in the order in which they appear 
	 * in the source or class file. For binary types, this includes synthetic fields.
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return the fields declared by this type
	 */
	IField[] getFields() throws JavaModelException;

	
Returns the fully qualified name of this type,
including qualification for any containing types and packages.
This is the name of the package, followed by '.',
followed by the type-qualified name.

Note: The enclosing type separator used in the type-qualified
name is '$', not '.'.

This method is fully equivalent to getFullyQualifiedName('$').
This is a handle-only method.
See Also:
getTypeQualifiedName.getTypeQualifiedName()
getFullyQualifiedName(char)
Returns:
the fully qualified name of this type/**
	 * Returns the fully qualified name of this type,
	 * including qualification for any containing types and packages.
	 * This is the name of the package, followed by <code>'.'</code>,
	 * followed by the type-qualified name.
	 * <p>
	 * <b>Note</b>: The enclosing type separator used in the type-qualified
	 * name is <code>'$'</code>, not <code>'.'</code>.
	 * </p>
	 * This method is fully equivalent to <code>getFullyQualifiedName('$')</code>.
	 * This is a handle-only method.
	 *
	 * @see IType#getTypeQualifiedName()
	 * @see IType#getFullyQualifiedName(char)
	 * @return the fully qualified name of this type
	 */
	String getFullyQualifiedName();

	
Returns the fully qualified name of this type,
including qualification for any containing types and packages.
This is the name of the package, followed by '.',
followed by the type-qualified name using the enclosingTypeSeparator.
For example:

the fully qualified name of a class B defined as a member of a class A in a compilation unit A.java
    in a package x.y using the '.' separator is "x.y.A.B"
the fully qualified name of a class B defined as a member of a class A in a compilation unit A.java
    in a package x.y using the '$' separator is "x.y.A$B"
the fully qualified name of a binary type whose class file is x/y/A$B.class
    using the '.' separator is "x.y.A.B"
the fully qualified name of a binary type whose class file is x/y/A$B.class
    using the '$' separator is "x.y.A$B"
the fully qualified name of an anonymous binary type whose class file is x/y/A$1.class
    using the '.' separator is "x.y.A.1"

This is a handle-only method.
Params:
enclosingTypeSeparator – the given enclosing type separator
See Also:
getTypeQualifiedName(char)
Returns:
the fully qualified name of this type, including qualification for any containing types and packages
Since:
2.0/**
	 * Returns the fully qualified name of this type,
	 * including qualification for any containing types and packages.
	 * This is the name of the package, followed by <code>'.'</code>,
	 * followed by the type-qualified name using the <code>enclosingTypeSeparator</code>.
	 *
	 * For example:
	 * <ul>
	 * <li>the fully qualified name of a class B defined as a member of a class A in a compilation unit A.java
	 *     in a package x.y using the '.' separator is "x.y.A.B"</li>
	 * <li>the fully qualified name of a class B defined as a member of a class A in a compilation unit A.java
	 *     in a package x.y using the '$' separator is "x.y.A$B"</li>
	 * <li>the fully qualified name of a binary type whose class file is x/y/A$B.class
	 *     using the '.' separator is "x.y.A.B"</li>
	 * <li>the fully qualified name of a binary type whose class file is x/y/A$B.class
	 *     using the '$' separator is "x.y.A$B"</li>
	 * <li>the fully qualified name of an anonymous binary type whose class file is x/y/A$1.class
	 *     using the '.' separator is "x.y.A.1"</li>
	 * </ul>
	 *
	 * This is a handle-only method.
	 *
	 * @param enclosingTypeSeparator the given enclosing type separator
	 * @return the fully qualified name of this type, including qualification for any containing types and packages
	 * @see IType#getTypeQualifiedName(char)
	 * @since 2.0
	 */
	String getFullyQualifiedName(char enclosingTypeSeparator);

	
Returns this type's fully qualified name using a '.' enclosing type separator
followed by its type parameters between angle brackets if it is a generic type.
For example, "p.X<T>", "java.util.Map<java.lang.String, p.X>"
Throws:
JavaModelException – if this element does not exist or if an
     exception occurs while accessing its corresponding resource.
Returns:
the fully qualified parameterized representation of this type
Since:
3.1/**
	 * Returns this type's fully qualified name using a '.' enclosing type separator
	 * followed by its type parameters between angle brackets if it is a generic type.
	 * For example, "p.X&lt;T&gt;", "java.util.Map&lt;java.lang.String, p.X&gt;"
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *      exception occurs while accessing its corresponding resource.
	 * @return the fully qualified parameterized representation of this type
	 * @since 3.1
	 */
	String getFullyQualifiedParameterizedName() throws JavaModelException;

	
Returns the initializer with the specified position relative to
the order they are defined in the source.
Numbering starts at 1 (thus the first occurrence is occurrence 1, not occurrence 0).
This is a handle-only method.  The initializer may or may not be present.
Params:
occurrenceCount – the specified position
Returns:
the initializer with the specified position relative to the order they are defined in the source/**
	 * Returns the initializer with the specified position relative to
	 * the order they are defined in the source.
	 * Numbering starts at 1 (thus the first occurrence is occurrence 1, not occurrence 0).
	 * This is a handle-only method.  The initializer may or may not be present.
	 *
	 * @param occurrenceCount the specified position
	 * @return the initializer with the specified position relative to the order they are defined in the source
	 */
	IInitializer getInitializer(int occurrenceCount);

	
Returns the initializers declared by this type. For binary types this is an 
empty collection. For source types, the results are listed in the order in 
which they appear in the source. 
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
the initializers declared by this type/**
	 * Returns the initializers declared by this type. For binary types this is an 
	 * empty collection. For source types, the results are listed in the order in 
	 * which they appear in the source. 
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return the initializers declared by this type
	 */
	IInitializer[] getInitializers() throws JavaModelException;

	
Returns the binding key for this type only if the given type is resolved. A binding key is a key that uniquely identifies this type. It allows access to generic info for parameterized types. 
If the given type is not resolved, the returned key is simply the java element's key.

See Also:
IBinding.getKey()
BindingKey
isResolved()
Returns:
the binding key for this type
Since:
3.1/**
	 * Returns the binding key for this type only if the given type is {@link #isResolved() resolved}.
	 * A binding key is a key that uniquely identifies this type. It allows access
	 * to generic info for parameterized types.
	 *
	 * <p>If the given type is not resolved, the returned key is simply the java element's key.
	 * </p>
	 * @return the binding key for this type
	 * @see org.eclipse.jdt.core.dom.IBinding#getKey()
	 * @see BindingKey
	 * @since 3.1
	 * @see #isResolved()
	 */
	String getKey();

	
Returns the method with the specified name and parameter types
in this type (for example, "foo", {"I", "QString;"}).
To get the handle for a constructor, the name specified must be the
simple name of the enclosing type.
This is a handle-only method.  The method may or may not be present.
 The type signatures may be either unresolved (for source types) or resolved (for binary types), and either basic (for basic types) or rich (for parameterized types). See Signature for details. Note that the parameter type signatures for binary methods are expected to be dot-based. 
Params:
name – the given name
parameterTypeSignatures – the given parameter types
Returns:
the method with the specified name and parameter types in this type/**
	 * Returns the method with the specified name and parameter types
	 * in this type (for example, <code>"foo", {"I", "QString;"}</code>).
	 * To get the handle for a constructor, the name specified must be the
	 * simple name of the enclosing type.
	 * This is a handle-only method.  The method may or may not be present.
	 * <p>
	 * The type signatures may be either unresolved (for source types)
	 * or resolved (for binary types), and either basic (for basic types)
	 * or rich (for parameterized types). See {@link Signature} for details.
	 * Note that the parameter type signatures for binary methods are expected 
	 * to be dot-based.
	 * </p>
	 *
	 * @param name the given name
	 * @param parameterTypeSignatures the given parameter types
	 * @return the method with the specified name and parameter types in this type
	 */
	IMethod getMethod(String name, String[] parameterTypeSignatures);

	
Returns the methods and constructors declared by this type.
For binary types, this may include the special <clinit> method
and synthetic methods.

The results are listed in the order in which they appear in the source or class file. 

Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
the methods and constructors declared by this type/**
	 * Returns the methods and constructors declared by this type.
	 * For binary types, this may include the special <code>&lt;clinit&gt;</code> method
	 * and synthetic methods.
	 * <p>
	 * The results are listed in the order in which they appear in the source or class file. 
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return the methods and constructors declared by this type
	 */
	IMethod[] getMethods() throws JavaModelException;

	
Returns the package fragment in which this element is defined.
This is a handle-only method.
Returns:
the package fragment in which this element is defined/**
	 * Returns the package fragment in which this element is defined.
	 * This is a handle-only method.
	 *
	 * @return the package fragment in which this element is defined
	 */
	IPackageFragment getPackageFragment();

	
Returns the name of this type's superclass, or null
for source types that do not specify a superclass.

For interfaces, the superclass name is always "java.lang.Object". For source types, the name as declared is returned, for binary types, the resolved, qualified name is returned. For anonymous types, the superclass name is the name appearing after the 'new' keyword'. If the superclass is a parameterized type, the string may include its type arguments enclosed in "<>". If the returned string is needed for anything other than display purposes, use getSuperclassTypeSignature() which returns a structured type signature string containing more precise information. 
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
the name of this type's superclass, or null for source types that do not specify a superclass/**
	 * Returns the name of this type's superclass, or <code>null</code>
	 * for source types that do not specify a superclass.
	 * <p>
	 * For interfaces, the superclass name is always <code>"java.lang.Object"</code>.
	 * For source types, the name as declared is returned, for binary types,
	 * the resolved, qualified name is returned.
	 * For anonymous types, the superclass name is the name appearing after the 'new' keyword'.
	 * If the superclass is a parameterized type, the string
	 * may include its type arguments enclosed in "&lt;&gt;".
	 * If the returned string is needed for anything other than display
	 * purposes, use {@link #getSuperclassTypeSignature()} which returns
	 * a structured type signature string containing more precise information.
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return the name of this type's superclass, or <code>null</code> for source types that do not specify a superclass
	 */
	String getSuperclassName() throws JavaModelException;

	
Returns the type signature of this type's superclass, or
null if none.
 The type signature may be either unresolved (for source types) or resolved (for binary types), and either basic (for basic types) or rich (for parameterized types). See Signature for details. 
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
the type signature of this type's superclass, or
null if none
Since:
3.0/**
	 * Returns the type signature of this type's superclass, or
	 * <code>null</code> if none.
	 * <p>
	 * The type signature may be either unresolved (for source types)
	 * or resolved (for binary types), and either basic (for basic types)
	 * or rich (for parameterized types). See {@link Signature} for details.
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return the type signature of this type's superclass, or
	 * <code>null</code> if none
	 * @since 3.0
	 */
	String getSuperclassTypeSignature() throws JavaModelException;

	
Returns the type signatures of the interfaces that this type
implements or extends, in the order in which they are listed in the
source.

For classes and enum types, this gives the interfaces that this
class implements. For interfaces and annotation types,
this gives the interfaces that this interface extends.
An empty collection is returned if this type does not implement or
extend any interfaces. For anonymous types, an empty collection is
always returned.

 The type signatures may be either unresolved (for source types) or resolved (for binary types), and either basic (for basic types) or rich (for parameterized types). See Signature for details. 
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
 the type signatures of interfaces that this type implements
or extends, in the order in which they are listed in the source,
an empty collection if none
Since:
3.0/**
	 * Returns the type signatures of the interfaces that this type
	 * implements or extends, in the order in which they are listed in the
	 * source.
	 * <p>
	 * For classes and enum types, this gives the interfaces that this
	 * class implements. For interfaces and annotation types,
	 * this gives the interfaces that this interface extends.
	 * An empty collection is returned if this type does not implement or
	 * extend any interfaces. For anonymous types, an empty collection is
	 * always returned.
	 * </p>
	 * <p>
	 * The type signatures may be either unresolved (for source types)
	 * or resolved (for binary types), and either basic (for basic types)
	 * or rich (for parameterized types). See {@link Signature} for details.
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return  the type signatures of interfaces that this type implements
	 * or extends, in the order in which they are listed in the source,
	 * an empty collection if none
	 * @since 3.0
	 */
	String[] getSuperInterfaceTypeSignatures() throws JavaModelException;

	
Returns the names of interfaces that this type implements or extends,
in the order in which they are listed in the source.
 For classes, this gives the interfaces that this class implements. For interfaces, this gives the interfaces that this interface extends. An empty collection is returned if this type does not implement or extend any interfaces. For source types, simple names are returned, for binary types, qualified names are returned. For anonymous types, an empty collection is always returned. If the list of supertypes includes parameterized types, the string may include type arguments enclosed in "<>". If the result is needed for anything other than display purposes, use getSuperInterfaceTypeSignatures() which returns structured signature strings containing more precise information. 
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
 the names of interfaces that this type implements or extends, in the order in which they are listed in the source,
an empty collection if none/**
	 * Returns the names of interfaces that this type implements or extends,
	 * in the order in which they are listed in the source.
	 * <p>
	 * For classes, this gives the interfaces that this class implements.
	 * For interfaces, this gives the interfaces that this interface extends.
	 * An empty collection is returned if this type does not implement or
	 * extend any interfaces. For source types, simple names are returned,
	 * for binary types, qualified names are returned.
	 * For anonymous types, an empty collection is always returned.
	 * If the list of supertypes includes parameterized types,
	 * the string may include type arguments enclosed in "&lt;&gt;".
	 * If the result is needed for anything other than display
	 * purposes, use {@link #getSuperInterfaceTypeSignatures()} which returns
	 * structured signature strings containing more precise information.
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return  the names of interfaces that this type implements or extends, in the order in which they are listed in the source,
	 * an empty collection if none
	 */
	String[] getSuperInterfaceNames() throws JavaModelException;

	
Returns the formal type parameter signatures for this type.
Returns an empty array if this type has no formal type parameters.
 The formal type parameter signatures may be either unresolved (for source types) or resolved (for binary types). See Signature for details. 
Throws:
JavaModelException – if this element does not exist or if an
     exception occurs while accessing its corresponding resource.
See Also:
Signature
Returns:
the formal type parameter signatures of this type,
in the order declared in the source, an empty array if none
Since:
3.0/**
	 * Returns the formal type parameter signatures for this type.
	 * Returns an empty array if this type has no formal type parameters.
	 * <p>
	 * The formal type parameter signatures may be either unresolved (for source
	 * types) or resolved (for binary types). See {@link Signature} for details.
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *      exception occurs while accessing its corresponding resource.
	 * @return the formal type parameter signatures of this type,
	 * in the order declared in the source, an empty array if none
	 * @see Signature
	 * @since 3.0
	 */
	String[] getTypeParameterSignatures() throws JavaModelException;

	
Returns the formal type parameters for this type.
Returns an empty array if this type has no formal type parameters.
Throws:
JavaModelException – if this element does not exist or if an
     exception occurs while accessing its corresponding resource.
Returns:
the formal type parameters of this type,
in the order declared in the source, an empty array if none
Since:
3.1/**
	 * Returns the formal type parameters for this type.
	 * Returns an empty array if this type has no formal type parameters.
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *      exception occurs while accessing its corresponding resource.
	 * @return the formal type parameters of this type,
	 * in the order declared in the source, an empty array if none
	 * @since 3.1
	 */
	ITypeParameter[] getTypeParameters() throws JavaModelException;

	
Returns the member type declared in this type with the given simple name.
This is a handle-only method. The type may or may not exist.
Params:
name – the given simple name
Returns:
the member type declared in this type with the given simple name/**
	 * Returns the member type declared in this type with the given simple name.
	 * This is a handle-only method. The type may or may not exist.
	 *
	 * @param name the given simple name
	 * @return the member type declared in this type with the given simple name
	 */
	IType getType(String name);

	
Returns the type parameter declared in this type with the given name.
This is a handle-only method. The type parameter may or may not exist.
Params:
name – the given simple name
Returns:
the type parameter declared in this type with the given name
Since:
3.1/**
	 * Returns the type parameter declared in this type with the given name.
	 * This is a handle-only method. The type parameter may or may not exist.
	 *
	 * @param name the given simple name
	 * @return the type parameter declared in this type with the given name
	 * @since 3.1
	 */
	ITypeParameter getTypeParameter(String name);

	
Returns the type-qualified name of this type,
including qualification for any enclosing types,
but not including package qualification.
For source types, this consists of the simple names of any enclosing types,
separated by '$', followed by the simple name of this type
or the occurrence count of this type if it is anonymous.
For binary types, this is the name of the class file without the ".class" suffix.
This method is fully equivalent to getTypeQualifiedName('$').
This is a handle-only method.
See Also:
getTypeQualifiedName(char)
Returns:
the type-qualified name of this type/**
	 * Returns the type-qualified name of this type,
	 * including qualification for any enclosing types,
	 * but not including package qualification.
	 * For source types, this consists of the simple names of any enclosing types,
	 * separated by <code>'$'</code>, followed by the simple name of this type
	 * or the occurrence count of this type if it is anonymous.
	 * For binary types, this is the name of the class file without the ".class" suffix.
	 * This method is fully equivalent to <code>getTypeQualifiedName('$')</code>.
	 * This is a handle-only method.
	 *
	 * @see #getTypeQualifiedName(char)
	 * @return the type-qualified name of this type
	 */
	String getTypeQualifiedName();

	
Returns the type-qualified name of this type,
including qualification for any enclosing types,
but not including package qualification.
For source types, this consists of the simple names of any enclosing types,
separated by enclosingTypeSeparator, followed by the
simple name of this type  or the occurrence count of this type if it is anonymous.
For binary types, this is the name of the class file without the ".class" suffix,
and - since 3.4 - the '$' characters in the class file name are replaced with the
enclosingTypeSeparator character.
For example:

the type qualified name of a class B defined as a member of a class A
    using the '.' separator is "A.B"
the type qualified name of a class B defined as a member of a class A
    using the '$' separator is "A$B"
the type qualified name of a binary type whose class file is A$B.class
    using the '.' separator is "A.B"
the type qualified name of a binary type whose class file is A$B.class
    using the '$' separator is "A$B"
the type qualified name of an anonymous binary type whose class file is A$1.class
    using the '.' separator is "A.1"

This is a handle-only method.
Params:
enclosingTypeSeparator – the specified enclosing type separator
Returns:
the type-qualified name of this type
Since:
2.0/**
	 * Returns the type-qualified name of this type,
	 * including qualification for any enclosing types,
	 * but not including package qualification.
	 * For source types, this consists of the simple names of any enclosing types,
	 * separated by <code>enclosingTypeSeparator</code>, followed by the
	 * simple name of this type  or the occurrence count of this type if it is anonymous.
	 * For binary types, this is the name of the class file without the ".class" suffix,
	 * and - since 3.4 - the '$' characters in the class file name are replaced with the
	 * <code>enclosingTypeSeparator</code> character.
	 *
	 * For example:
	 * <ul>
	 * <li>the type qualified name of a class B defined as a member of a class A
	 *     using the '.' separator is "A.B"</li>
	 * <li>the type qualified name of a class B defined as a member of a class A
	 *     using the '$' separator is "A$B"</li>
	 * <li>the type qualified name of a binary type whose class file is A$B.class
	 *     using the '.' separator is "A.B"</li>
	 * <li>the type qualified name of a binary type whose class file is A$B.class
	 *     using the '$' separator is "A$B"</li>
	 * <li>the type qualified name of an anonymous binary type whose class file is A$1.class
	 *     using the '.' separator is "A.1"</li>
	 * </ul>
	 *
	 * This is a handle-only method.
	 *
	 * @param enclosingTypeSeparator the specified enclosing type separator
	 * @return the type-qualified name of this type
	 * @since 2.0
	 */
	String getTypeQualifiedName(char enclosingTypeSeparator);

	
Returns the immediate member types declared by this type.
The results are listed in the order in which they appear in the source or class file.
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
the immediate member types declared by this type/**
	 * Returns the immediate member types declared by this type.
	 * The results are listed in the order in which they appear in the source or class file.
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return the immediate member types declared by this type
	 */
	IType[] getTypes() throws JavaModelException;

	
Returns whether this type represents an anonymous type.
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
true if this type represents an anonymous type, false otherwise
Since:
2.0/**
	 * Returns whether this type represents an anonymous type.
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return true if this type represents an anonymous type, false otherwise
	 * @since 2.0
	 */
	boolean isAnonymous() throws JavaModelException;

	
Returns whether this type represents a class.

Note that a class can neither be an interface, an enumeration class, nor an annotation type.

Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
true if this type represents a class, false otherwise/**
	 * Returns whether this type represents a class.
	 * <p>
	 * Note that a class can neither be an interface, an enumeration class, nor an annotation type.
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return true if this type represents a class, false otherwise
	 */
	boolean isClass() throws JavaModelException;

	
Returns whether this type represents an enumeration class.

Note that an enumeration class can neither be a class, an interface, nor an annotation type.

Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
true if this type represents an enumeration class,
false otherwise
Since:
3.0/**
	 * Returns whether this type represents an enumeration class.
	 * <p>
	 * Note that an enumeration class can neither be a class, an interface, nor an annotation type.
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return true if this type represents an enumeration class,
	 * false otherwise
	 * @since 3.0
	 */
	boolean isEnum() throws JavaModelException;

	
Returns whether this type represents an interface.

Note that an interface can also be an annotation type, but it can neither be a class nor an enumeration class.

Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
true if this type represents an interface, false otherwise/**
	 * Returns whether this type represents an interface.
	 * <p>
	 * Note that an interface can also be an annotation type, but it can neither be a class nor an enumeration class.
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return true if this type represents an interface, false otherwise
	 */
	boolean isInterface() throws JavaModelException;

	
Returns whether this type represents an annotation type.

Note that an annotation type is also an interface, but it can neither be a class nor an enumeration class.

Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
true if this type represents an annotation type,
false otherwise
Since:
3.0/**
	 * Returns whether this type represents an annotation type.
	 * <p>
	 * Note that an annotation type is also an interface, but it can neither be a class nor an enumeration class.
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return true if this type represents an annotation type,
	 * false otherwise
	 * @since 3.0
	 */
	boolean isAnnotation() throws JavaModelException;

	
Returns whether this type represents a local type. For an anonymous type, 
this method returns true.

Note: This deviates from JLS3 14.3, which states that anonymous types are 
not local types since they do not have a name.

Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
See Also:
ITypeBinding.isLocal()
Returns:
true if this type represents a local type, false otherwise
Since:
2.0/**
	 * Returns whether this type represents a local type. For an anonymous type, 
	 * this method returns true.
	 * <p>
	 * Note: This deviates from JLS3 14.3, which states that anonymous types are 
	 * not local types since they do not have a name.
	 * </p>
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return true if this type represents a local type, false otherwise
	 * @see org.eclipse.jdt.core.dom.ITypeBinding#isLocal()
	 * @since 2.0
	 */
	boolean isLocal() throws JavaModelException;

	
Returns whether this type represents a member type.
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
true if this type represents a member type, false otherwise
Since:
2.0/**
	 * Returns whether this type represents a member type.
	 *
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return true if this type represents a member type, false otherwise
	 * @since 2.0
	 */
	boolean isMember() throws JavaModelException;
	
Returns whether this type represents a resolved type.
If a type is resolved, its key contains resolved information.
Returns:
whether this type represents a resolved type.
Since:
3.1/**
	 * Returns whether this type represents a resolved type.
	 * If a type is resolved, its key contains resolved information.
	 *
	 * @return whether this type represents a resolved type.
	 * @since 3.1
	 */
	boolean isResolved();
	
Loads a previously saved ITypeHierarchy from an input stream. A type hierarchy can
be stored using ITypeHierachy#store(OutputStream).
Only hierarchies originally created by the following methods can be loaded:

IType#newSupertypeHierarchy(IProgressMonitor)
IType#newTypeHierarchy(IJavaProject, IProgressMonitor)
IType#newTypeHierarchy(IProgressMonitor)

Params:
input – stream where hierarchy will be read
monitor – the given progress monitor
Throws:
JavaModelException – if the hierarchy could not be restored, reasons include:
     - type is not the focus of the hierarchy or
	- unable to read the input stream (wrong format, IOException during reading, ...)
See Also:
ITypeHierarchy.store(OutputStream, IProgressMonitor)
Returns:
the stored hierarchy
Since:
2.1/**
	 * Loads a previously saved ITypeHierarchy from an input stream. A type hierarchy can
	 * be stored using ITypeHierachy#store(OutputStream).
	 *
	 * Only hierarchies originally created by the following methods can be loaded:
	 * <ul>
	 * <li>IType#newSupertypeHierarchy(IProgressMonitor)</li>
	 * <li>IType#newTypeHierarchy(IJavaProject, IProgressMonitor)</li>
	 * <li>IType#newTypeHierarchy(IProgressMonitor)</li>
	 * </ul>
	 *
	 * @param input stream where hierarchy will be read
	 * @param monitor the given progress monitor
	 * @return the stored hierarchy
	 * @exception JavaModelException if the hierarchy could not be restored, reasons include:
	 *      - type is not the focus of the hierarchy or
	 *		- unable to read the input stream (wrong format, IOException during reading, ...)
	 * @see ITypeHierarchy#store(java.io.OutputStream, IProgressMonitor)
	 * @since 2.1
	 */
	ITypeHierarchy loadTypeHierachy(InputStream input, IProgressMonitor monitor) throws JavaModelException;
	
Creates and returns a type hierarchy for this type containing
this type and all of its supertypes.
Params:
monitor – the given progress monitor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
a type hierarchy for this type containing this type and all of its supertypes/**
	 * Creates and returns a type hierarchy for this type containing
	 * this type and all of its supertypes.
	 *
	 * @param monitor the given progress monitor
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return a type hierarchy for this type containing this type and all of its supertypes
	 */
	ITypeHierarchy newSupertypeHierarchy(IProgressMonitor monitor) throws JavaModelException;

	
Creates and returns a type hierarchy for this type containing
this type and all of its supertypes, considering types in the given
working copies. In other words, the list of working copies will take
precedence over their original compilation units in the workspace.

Note that passing an empty working copy will be as if the original compilation
unit had been deleted.

Params:
workingCopies – the working copies that take precedence over their original compilation units
monitor – the given progress monitor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
a type hierarchy for this type containing this type and all of its supertypes
Since:
3.0/**
	 * Creates and returns a type hierarchy for this type containing
	 * this type and all of its supertypes, considering types in the given
	 * working copies. In other words, the list of working copies will take
	 * precedence over their original compilation units in the workspace.
	 * <p>
	 * Note that passing an empty working copy will be as if the original compilation
	 * unit had been deleted.
	 * </p>
	 *
	 * @param workingCopies the working copies that take precedence over their original compilation units
	 * @param monitor the given progress monitor
	 * @return a type hierarchy for this type containing this type and all of its supertypes
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 3.0
	 */
	ITypeHierarchy newSupertypeHierarchy(ICompilationUnit[] workingCopies, IProgressMonitor monitor)
		throws JavaModelException;

	
Creates and returns a type hierarchy for this type containing
this type and all of its supertypes, considering types in the given
working copies. In other words, the list of working copies will take
precedence over their original compilation units in the workspace.

Note that passing an empty working copy will be as if the original compilation
unit had been deleted.

Params:
workingCopies – the working copies that take precedence over their original compilation units
monitor – the given progress monitor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
a type hierarchy for this type containing this type and all of its supertypes
Since:
2.0
Deprecated:
Use newSupertypeHierarchy(ICompilationUnit[], IProgressMonitor) instead/**
	 * Creates and returns a type hierarchy for this type containing
	 * this type and all of its supertypes, considering types in the given
	 * working copies. In other words, the list of working copies will take
	 * precedence over their original compilation units in the workspace.
	 * <p>
	 * Note that passing an empty working copy will be as if the original compilation
	 * unit had been deleted.
	 * </p>
	 *
	 * @param workingCopies the working copies that take precedence over their original compilation units
	 * @param monitor the given progress monitor
	 * @return a type hierarchy for this type containing this type and all of its supertypes
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 2.0
	 * @deprecated Use {@link #newSupertypeHierarchy(ICompilationUnit[], IProgressMonitor)} instead
	 */
	ITypeHierarchy newSupertypeHierarchy(IWorkingCopy[] workingCopies, IProgressMonitor monitor)
		throws JavaModelException;

	
Creates and returns a type hierarchy for this type containing
this type and all of its supertypes, considering types in the
working copies with the given owner.
In other words, the owner's working copies will take
precedence over their original compilation units in the workspace.

Note that if a working copy is empty, it will be as if the original compilation
unit had been deleted.

Params:
owner – the owner of working copies that take precedence over their original compilation units
monitor – the given progress monitor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
a type hierarchy for this type containing this type and all of its supertypes
Since:
3.0/**
	 * Creates and returns a type hierarchy for this type containing
	 * this type and all of its supertypes, considering types in the
	 * working copies with the given owner.
	 * In other words, the owner's working copies will take
	 * precedence over their original compilation units in the workspace.
	 * <p>
	 * Note that if a working copy is empty, it will be as if the original compilation
	 * unit had been deleted.
	 * <p>
	 *
	 * @param owner the owner of working copies that take precedence over their original compilation units
	 * @param monitor the given progress monitor
	 * @return a type hierarchy for this type containing this type and all of its supertypes
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 3.0
	 */
	ITypeHierarchy newSupertypeHierarchy(WorkingCopyOwner owner, IProgressMonitor monitor)
		throws JavaModelException;

	
Creates and returns a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes
in the context of the given project.
Params:
project – the given project
monitor – the given progress monitor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes
in the context of the given project/**
	 * Creates and returns a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes
	 * in the context of the given project.
	 *
	 * @param project the given project
	 * @param monitor the given progress monitor
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes
	 * in the context of the given project
	 */
	ITypeHierarchy newTypeHierarchy(IJavaProject project, IProgressMonitor monitor) throws JavaModelException;

	
Creates and returns a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes
in the context of the given project, considering types in the
working copies with the given owner.
In other words, the owner's working copies will take
precedence over their original compilation units in the workspace.

Note that if a working copy is empty, it will be as if the original compilation
unit had been deleted.

Params:
project – the given project
owner – the owner of working copies that take precedence over their original compilation units
monitor – the given progress monitor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes
in the context of the given project
Since:
3.0/**
	 * Creates and returns a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes
	 * in the context of the given project, considering types in the
	 * working copies with the given owner.
	 * In other words, the owner's working copies will take
	 * precedence over their original compilation units in the workspace.
	 * <p>
	 * Note that if a working copy is empty, it will be as if the original compilation
	 * unit had been deleted.
	 * <p>
	 *
	 * @param project the given project
	 * @param owner the owner of working copies that take precedence over their original compilation units
	 * @param monitor the given progress monitor
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes
	 * in the context of the given project
	 * @since 3.0
	 */
	ITypeHierarchy newTypeHierarchy(IJavaProject project, WorkingCopyOwner owner, IProgressMonitor monitor) throws JavaModelException;

	
Creates and returns a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes in the workspace.
Params:
monitor – the given progress monitor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes in the workspace/**
	 * Creates and returns a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes in the workspace.
	 *
	 * @param monitor the given progress monitor
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @return a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes in the workspace
	 */
	ITypeHierarchy newTypeHierarchy(IProgressMonitor monitor) throws JavaModelException;

	
Creates and returns a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes in the workspace,
considering types in the given working copies. In other words, the list of working
copies that will take precedence over their original compilation units in the workspace.

Note that passing an empty working copy will be as if the original compilation
unit had been deleted.
Params:
workingCopies – the working copies that take precedence over their original compilation units
monitor – the given progress monitor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes in the workspace
Since:
3.0/**
	 * Creates and returns a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes in the workspace,
	 * considering types in the given working copies. In other words, the list of working
	 * copies that will take precedence over their original compilation units in the workspace.
	 * <p>
	 * Note that passing an empty working copy will be as if the original compilation
	 * unit had been deleted.
	 *
	 * @param workingCopies the working copies that take precedence over their original compilation units
	 * @param monitor the given progress monitor
	 * @return a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes in the workspace
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 3.0
	 */
	ITypeHierarchy newTypeHierarchy(ICompilationUnit[] workingCopies, IProgressMonitor monitor) throws JavaModelException;

	
Creates and returns a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes in the workspace,
considering types in the given working copies. In other words, the list of working
copies that will take precedence over their original compilation units in the workspace.

Note that passing an empty working copy will be as if the original compilation
unit had been deleted.
Params:
workingCopies – the working copies that take precedence over their original compilation units
monitor – the given progress monitor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes in the workspace
Since:
2.0
Deprecated:
Use newTypeHierarchy(ICompilationUnit[], IProgressMonitor) instead/**
	 * Creates and returns a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes in the workspace,
	 * considering types in the given working copies. In other words, the list of working
	 * copies that will take precedence over their original compilation units in the workspace.
	 * <p>
	 * Note that passing an empty working copy will be as if the original compilation
	 * unit had been deleted.
	 *
	 * @param workingCopies the working copies that take precedence over their original compilation units
	 * @param monitor the given progress monitor
	 * @return a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes in the workspace
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 2.0
	 * @deprecated Use {@link #newTypeHierarchy(ICompilationUnit[], IProgressMonitor)} instead
	 */
	ITypeHierarchy newTypeHierarchy(IWorkingCopy[] workingCopies, IProgressMonitor monitor) throws JavaModelException;

	
Creates and returns a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes in the workspace,
considering types in the working copies with the given owner.
In other words, the owner's working copies will take
precedence over their original compilation units in the workspace.

Note that if a working copy is empty, it will be as if the original compilation
unit had been deleted.

Params:
owner – the owner of working copies that take precedence over their original compilation units
monitor – the given progress monitor
Throws:
JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource.
Returns:
a type hierarchy for this type containing
this type, all of its supertypes, and all its subtypes in the workspace
Since:
3.0/**
	 * Creates and returns a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes in the workspace,
	 * considering types in the working copies with the given owner.
	 * In other words, the owner's working copies will take
	 * precedence over their original compilation units in the workspace.
	 * <p>
	 * Note that if a working copy is empty, it will be as if the original compilation
	 * unit had been deleted.
	 * <p>
	 *
	 * @param owner the owner of working copies that take precedence over their original compilation units
	 * @param monitor the given progress monitor
	 * @return a type hierarchy for this type containing
	 * this type, all of its supertypes, and all its subtypes in the workspace
	 * @exception JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource.
	 * @since 3.0
	 */
	ITypeHierarchy newTypeHierarchy(WorkingCopyOwner owner, IProgressMonitor monitor) throws JavaModelException;

	
Resolves the given type name within the context of this type (depending on the type hierarchy
and its imports).

Multiple answers might be found in case there are ambiguous matches.


Each matching type name is decomposed as an array of two strings, the first denoting the package
name (dot-separated) and the second being the type name. The package name is empty if it is the
default package. The type name is the type qualified name using a '.' enclosing type separator.


Returns null if unable to find any matching type.


For example, resolution of "Object" would typically return
{{"java.lang", "Object"}}. Another resolution that returns
{{"", "X.Inner"}} represents the inner type Inner defined in type X in the
default package.

Params:
typeName – the given type name
Throws:
JavaModelException – if code resolve could not be performed.
See Also:
getTypeQualifiedName(char)
Returns:
the resolved type names or null if unable to find any matching type/**
	 * Resolves the given type name within the context of this type (depending on the type hierarchy
	 * and its imports).
	 * <p>
	 * Multiple answers might be found in case there are ambiguous matches.
	 * </p>
	 * <p>
	 * Each matching type name is decomposed as an array of two strings, the first denoting the package
	 * name (dot-separated) and the second being the type name. The package name is empty if it is the
	 * default package. The type name is the type qualified name using a '.' enclosing type separator.
	 * </p>
	 * <p>
	 * Returns <code>null</code> if unable to find any matching type.
	 * </p>
	 *<p>
	 * For example, resolution of <code>"Object"</code> would typically return
	 * <code>{{"java.lang", "Object"}}</code>. Another resolution that returns
	 * <code>{{"", "X.Inner"}}</code> represents the inner type Inner defined in type X in the
	 * default package.
	 * </p>
	 *
	 * @param typeName the given type name
	 * @exception JavaModelException if code resolve could not be performed.
	 * @return the resolved type names or <code>null</code> if unable to find any matching type
	 * @see #getTypeQualifiedName(char)
	 */
	String[][] resolveType(String typeName) throws JavaModelException;

	
Resolves the given type name within the context of this type (depending on the type hierarchy
and its imports) and using the given owner's working copies, considering types in the
working copies with the given owner. In other words, the owner's working copies will take
precedence over their original compilation units in the workspace.

Note that if a working copy is empty, it will be as if the original compilation
unit had been deleted.

Multiple answers might be found in case there are ambiguous matches.


Each matching type name is decomposed as an array of two strings, the first denoting the package
name (dot-separated) and the second being the type name. The package name is empty if it is the
default package. The type name is the type qualified name using a '.' enclosing type separator.


Returns null if unable to find any matching type.


For example, resolution of "Object" would typically return
{{"java.lang", "Object"}}. Another resolution that returns
{{"", "X.Inner"}} represents the inner type Inner defined in type X in the
default package.

Params:
typeName – the given type name
owner – the owner of working copies that take precedence over their original compilation units
Throws:
JavaModelException – if code resolve could not be performed.
See Also:
getTypeQualifiedName(char)
Returns:
the resolved type names or null if unable to find any matching type
Since:
3.0/**
	 * Resolves the given type name within the context of this type (depending on the type hierarchy
	 * and its imports) and using the given owner's working copies, considering types in the
	 * working copies with the given owner. In other words, the owner's working copies will take
	 * precedence over their original compilation units in the workspace.
	 * <p>
	 * Note that if a working copy is empty, it will be as if the original compilation
	 * unit had been deleted.
	 * </p>
	 * <p>Multiple answers might be found in case there are ambiguous matches.
	 * </p>
	 * <p>
	 * Each matching type name is decomposed as an array of two strings, the first denoting the package
	 * name (dot-separated) and the second being the type name. The package name is empty if it is the
	 * default package. The type name is the type qualified name using a '.' enclosing type separator.
	 * </p>
	 * <p>
	 * Returns <code>null</code> if unable to find any matching type.
	 *</p>
	 *<p>
	 * For example, resolution of <code>"Object"</code> would typically return
	 * <code>{{"java.lang", "Object"}}</code>. Another resolution that returns
	 * <code>{{"", "X.Inner"}}</code> represents the inner type Inner defined in type X in the
	 * default package.
	 * </p>
	 *
	 * @param typeName the given type name
	 * @param owner the owner of working copies that take precedence over their original compilation units
	 * @exception JavaModelException if code resolve could not be performed.
	 * @return the resolved type names or <code>null</code> if unable to find any matching type
	 * @see #getTypeQualifiedName(char)
	 * @since 3.0
	 */
	String[][] resolveType(String typeName, WorkingCopyOwner owner) throws JavaModelException;
	
	
Returns whether this type represents a lambda expression.
Returns:
true if this type represents a lambda expression, false otherwise
Since:
3.10/**
	 * Returns whether this type represents a lambda expression.
	 *
	 * @return true if this type represents a lambda expression, false otherwise
	 * @since 3.10
	 */
	public boolean isLambda();

	
Strengthen the contract of the inherited method to signal that the returned class file is always an IOrdinaryClassFile. 
Since:
3.14/**
	 * Strengthen the contract of the inherited method to signal that the returned class file
	 * is always an {@link IOrdinaryClassFile}.
	 * @since 3.14
	 */
	@Override
	IOrdinaryClassFile getClassFile();
}