diff --git a/docs/org.eclipse.jst.ejb.doc.user/META-INF/MANIFEST.MF b/docs/org.eclipse.jst.ejb.doc.user/META-INF/MANIFEST.MF
index 2046508..0c5f2b1 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/META-INF/MANIFEST.MF
+++ b/docs/org.eclipse.jst.ejb.doc.user/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: %Plugin.name
 Bundle-SymbolicName: org.eclipse.jst.ejb.doc.user; singleton:=true
-Bundle-Version: 1.1.200.qualifier
+Bundle-Version: 1.1.300.qualifier
 Bundle-Vendor: %Bundle-Vendor
 Bundle-Localization: plugin
 Bundle-ActivationPolicy: lazy
diff --git a/docs/org.eclipse.jst.ejb.doc.user/myplugin.xml b/docs/org.eclipse.jst.ejb.doc.user/myplugin.xml
index cfce245..dff811c 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/myplugin.xml
+++ b/docs/org.eclipse.jst.ejb.doc.user/myplugin.xml
@@ -2,7 +2,7 @@
 <?eclipse version="3.6"?>
 <?NLS TYPE="org.eclipse.help.contexts"?>
 <!-- /*******************************************************************************
- * Copyright (c) 2000, 2010 IBM Corporation and others.
+ * Copyright (c) 2000, 2011 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/docs/org.eclipse.jst.ejb.doc.user/plugin.xml b/docs/org.eclipse.jst.ejb.doc.user/plugin.xml
index 0309989..dff811c 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/plugin.xml
+++ b/docs/org.eclipse.jst.ejb.doc.user/plugin.xml
@@ -2,7 +2,7 @@
 <?eclipse version="3.6"?>
 <?NLS TYPE="org.eclipse.help.contexts"?>
 <!-- /*******************************************************************************
- * Copyright (c) 2000, 2010 IBM Corporation and others.
+ * Copyright (c) 2000, 2011 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -23,5 +23,5 @@
    <extension point="org.eclipse.help.index">
 		<index file="org.eclipse.jst.ejb.doc.userindex.xml"/>
 	</extension>
-
+ 
 </plugin>
\ No newline at end of file
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/ccontentassist3.html b/docs/org.eclipse.jst.ejb.doc.user/topics/ccontentassist3.html
index 04030ff..0223f6c 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/ccontentassist3.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/ccontentassist3.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/cearch.html b/docs/org.eclipse.jst.ejb.doc.user/topics/cearch.html
index 95de00b..0ce84cb 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/cearch.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/cearch.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/ceclientjars.html b/docs/org.eclipse.jst.ejb.doc.user/topics/ceclientjars.html
index bb276fc..9142e44 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/ceclientjars.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/ceclientjars.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/cejb3.html b/docs/org.eclipse.jst.ejb.doc.user/topics/cejb3.html
index ada4d3e..ddb4e8a 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/cejb3.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/cejb3.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/cejb3vejb21.html b/docs/org.eclipse.jst.ejb.doc.user/topics/cejb3vejb21.html
index 739c14c..67e4758 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/cejb3vejb21.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/cejb3vejb21.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -162,7 +162,7 @@
 
 <div>
 <div class="familylinks">
-<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/ejbarch.html" title="This topic provides a high-level overview of the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version 3.0 architecture specification.">EJB 3.0 architecture</a></div>
+<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/ejbarch.html" title="This topic provides a high-level overview of the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version 3.0 architecture specification.">EJB 3.0 and EJB 3.1 architecture</a></div>
 </div>
 </div>
 
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/ceover.html b/docs/org.eclipse.jst.ejb.doc.user/topics/ceover.html
index 95b4c4c..83019b6 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/ceover.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/ceover.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -97,7 +97,7 @@
 
 <div>
 <ul class="ullinks">
-<li class="ulchildlink"><strong><a href="../topics/ejbarch.html">EJB 3.0 architecture</a></strong><br />
+<li class="ulchildlink"><strong><a href="../topics/ejbarch.html">EJB 3.0 and EJB 3.1 architecture</a></strong><br />
 This topic provides a high-level overview of the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version 3.0 architecture specification.</li>
 <li class="ulchildlink"><strong><a href="../topics/cejb3.html">Developing EJB 3.1 Applications</a></strong><br />
 You can use the workbench to develop and test enterprise beans that conform to the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) 3.10 specification.</li>
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/ceresrc.html b/docs/org.eclipse.jst.ejb.doc.user/topics/ceresrc.html
index b798ebc..3697cd4 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/ceresrc.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/ceresrc.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/cpojosandee5.html b/docs/org.eclipse.jst.ejb.doc.user/topics/cpojosandee5.html
index 1758fcb..3d0c94f 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/cpojosandee5.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/cpojosandee5.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -97,7 +97,7 @@
 
 <div>
 <div class="familylinks">
-<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/ejbarch.html" title="This topic provides a high-level overview of the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version 3.0 architecture specification.">EJB 3.0 architecture</a></div>
+<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/ejbarch.html" title="This topic provides a high-level overview of the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version 3.0 architecture specification.">EJB 3.0 and EJB 3.1 architecture</a></div>
 </div>
 </div>
 
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/ejbarch.dita b/docs/org.eclipse.jst.ejb.doc.user/topics/ejbarch.dita
index a76a1c3..5ac3c4d 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/ejbarch.dita
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/ejbarch.dita
@@ -1,31 +1,35 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--Arbortext, Inc., 1988-2006, v.4002-->
+<?xml version="1.0" encoding="UTF-8"?>
+<!--Arbortext, Inc., 1988-2009, v.4002-->
 <!DOCTYPE concept PUBLIC "-//OASIS//DTD DITA Concept//EN"
  "concept.dtd">
+<?Pub Sty _display FontColor="red"?>
 <concept id="ejbarch" xml:lang="en-us">
-<title>EJB 3.0 architecture</title>
-<shortdesc>This topic provides a high-level overview of the distributed component
-architecture defined in the Sun Microsystems Enterprise <tm tmclass="special"
-tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="JavaBeans">JavaBeans</tm> (EJB)
-version 3.0 architecture specification.</shortdesc>
+<title>EJB 3.0 and EJB 3.1 architecture</title><?Pub Caret 8?>
+<shortdesc>This topic provides a high-level overview of the distributed
+component architecture defined in the Sun Microsystems Enterprise <tm
+tmclass="special" tmowner="Sun Microsystems, Inc." tmtype="tm"
+trademark="JavaBeans">JavaBeans</tm> (EJB) version 3.0 architecture
+specification.</shortdesc>
 <prolog><metadata>
-<keywords><indexterm>architecture<indexterm>EJB 3.0</indexterm></indexterm>
-<indexterm>EJB 3.0<indexterm>architecture<indexterm>3.0</indexterm></indexterm></indexterm>
+<keywords><indexterm>architecture<indexterm>EJB 3.0 and EJB 3.1</indexterm></indexterm>
+<indexterm>EJB 3.0 and EJB 3.1<indexterm>architecture<indexterm>3.0</indexterm></indexterm></indexterm>
 </keywords>
 </metadata></prolog>
 <conbody>
-<p><b>Enterprise <tm tmclass="special" tmowner="Sun Microsystems, Inc." tmtype="tm"
-trademark="JavaBeans">JavaBeans</tm></b> is a standard server-side component
-model for distributed business applications. The EJB specification is part
-of the <b><tm tmclass="special" tmowner="Sun Microsystems, Inc." tmtype="tm"
-trademark="Java">Java</tm> Platform Enterprise Edition</b>.</p>
-<p><b>EJB 3.0</b> makes it much easier to develop EJBs, using annotations
-rather than the complex deployment descriptors used in version 2.x. The use
-of home and remote interfaces and the <i>ejb-jar.xml</i> file are also no
-longer required in this release. They are replaced with a business interface
-and a bean class that implements the interface.</p>
-<p>For more information about EJB 3.0 specification go to the following Web
-site: <xref format="html" href="http://java.sun.com/products/ejb/docs.html#specs"
-scope="external">http://java.sun.com<desc></desc></xref> </p>
+<p><b>Enterprise <tm tmclass="special" tmowner="Sun Microsystems, Inc."
+tmtype="tm" trademark="JavaBeans">JavaBeans</tm></b> is a standard
+server-side component model for distributed business applications.
+The EJB specification is part of the <b><tm tmclass="special"
+tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> Platform
+Enterprise Edition</b>.</p>
+<p><b>EJB 3.0 and EJB 3.1</b> makes it much easier to develop EJBs,
+using annotations rather than the complex deployment descriptors used
+in version 2.x. The use of home and remote interfaces and the <i>ejb-jar.xml</i> file
+are also no longer required in this release. They are replaced with
+a business interface and a bean class that implements the interface.</p>
+<p>For more information about EJB 3.0 and EJB 3.1 specification go
+to the following Web site: <xref format="html"
+href="http://java.sun.com/products/ejb/docs.html#specs" scope="external">http://java.sun.com<desc></desc></xref> </p>
 </conbody>
 </concept>
+<?Pub *0000001865?>
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/ejbarch.html b/docs/org.eclipse.jst.ejb.doc.user/topics/ejbarch.html
index 6110c09..8ed241d 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/ejbarch.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/ejbarch.html
@@ -2,17 +2,17 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
 <meta content="concept" name="DC.Type" />
-<meta name="DC.Title" content="EJB 3.0 architecture" />
+<meta name="DC.Title" content="EJB 3.0 and EJB 3.1 architecture" />
 <meta name="abstract" content="This topic provides a high-level overview of the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version 3.0 architecture specification." />
 <meta name="description" content="This topic provides a high-level overview of the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version 3.0 architecture specification." />
-<meta content="architecture, EJB 3.0, 3.0" name="DC.subject" />
-<meta content="architecture, EJB 3.0, 3.0" name="keywords" />
+<meta content="architecture, EJB 3.0 and EJB 3.1, 3.0" name="DC.subject" />
+<meta content="architecture, EJB 3.0 and EJB 3.1, 3.0" name="keywords" />
 <meta scheme="URI" name="DC.Relation" content="../topics/ceover.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/cpojosandee5.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/cejb3vejb21.html" />
@@ -20,31 +20,32 @@
 <meta content="ejbarch" name="DC.Identifier" />
 <meta content="en-us" name="DC.Language" />
 <link href="../../org.eclipse.wst.doc.user/common.css" type="text/css" rel="stylesheet" />
-<title>EJB 3.0 architecture</title>
+<title>EJB 3.0 and EJB 3.1 architecture</title>
 </head>
 <body id="ejbarch"><a name="ejbarch"><!-- --></a>
 
 
-<h1 class="topictitle1">EJB 3.0 architecture</h1>
+<h1 class="topictitle1">EJB 3.0 and EJB 3.1 architecture</h1>
 
 
 
-<div><p>This topic provides a high-level overview of the distributed component
-architecture defined in the Sun Microsystems Enterprise JavaBeans™ (EJB)
-version 3.0 architecture specification.</p>
+<div><p>This topic provides a high-level overview of the distributed
+component architecture defined in the Sun Microsystems Enterprise JavaBeans™ (EJB) version 3.0 architecture
+specification.</p>
 
-<p><strong>Enterprise JavaBeans</strong> is a standard server-side component
-model for distributed business applications. The EJB specification is part
-of the <strong>Java™ Platform Enterprise Edition</strong>.</p>
+<p><strong>Enterprise JavaBeans</strong> is a standard
+server-side component model for distributed business applications.
+The EJB specification is part of the <strong>Java™ Platform
+Enterprise Edition</strong>.</p>
 
-<p><strong>EJB 3.0</strong> makes it much easier to develop EJBs, using annotations
-rather than the complex deployment descriptors used in version 2.x. The use
-of home and remote interfaces and the <em>ejb-jar.xml</em> file are also no
-longer required in this release. They are replaced with a business interface
-and a bean class that implements the interface.</p>
+<p><strong>EJB 3.0 and EJB 3.1</strong> makes it much easier to develop EJBs,
+using annotations rather than the complex deployment descriptors used
+in version 2.x. The use of home and remote interfaces and the <em>ejb-jar.xml</em> file
+are also no longer required in this release. They are replaced with
+a business interface and a bean class that implements the interface.</p>
 
-<p>For more information about EJB 3.0 specification go to the following Web
-site: <a href="http://java.sun.com/products/ejb/docs.html#specs" target="_blank" title="">http://java.sun.com</a> </p>
+<p>For more information about EJB 3.0 and EJB 3.1 specification go
+to the following Web site: <a href="http://java.sun.com/products/ejb/docs.html#specs" target="_blank" title="">http://java.sun.com</a> </p>
 
 </div>
 
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/sessbwiz.dita b/docs/org.eclipse.jst.ejb.doc.user/topics/sessbwiz.dita
index 1126944..057cb1f 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/sessbwiz.dita
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/sessbwiz.dita
@@ -1,103 +1,114 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--Arbortext, Inc., 1988-2006, v.4002-->
+<?xml version="1.0" encoding="UTF-8"?>
+<!--Arbortext, Inc., 1988-2009, v.4002-->
 <!DOCTYPE task PUBLIC "-//OASIS//DTD DITA Task//EN"
  "task.dtd">
 <task id="sessbwiz" xml:lang="en-us">
 <title>Creating EJB Session Beans</title>
-<shortdesc>You can use a wizard to create a session bean and add it to your
-project.</shortdesc>
+<shortdesc>You can use a wizard to create a session bean and add it
+to your project.</shortdesc>
 <prolog><metadata>
 <keywords><indexterm>session beans</indexterm><indexterm>creating</indexterm>
 </keywords>
 </metadata></prolog>
 <taskbody>
-<context><p>The session bean wizard helps you create an Enterprise session
-bean by walking you through the creation process and by providing you with
-output files that you can use or that you can modify for use with your application.</p> <p>To
-create a session bean, complete the following steps:</p></context>
+<context><p>The session bean wizard helps you create an Enterprise
+session bean by walking you through the creation process and by providing
+you with output files that you can use or that you can modify for
+use with your application.</p> <p>To create a session bean, complete
+the following steps:</p></context>
 <steps>
-<step><cmd>From the <tm tmclass="special" tmowner="Sun Microsystems, Inc."
-tmtype="tm" trademark="Java">Java</tm> EE perspective, expand your  EJB project
-in the Project Explorer view.</cmd></step>
+<step><cmd>From the <tm tmclass="special"
+tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> EE
+perspective, expand your  EJB project in the Project Explorer view.</cmd>
+</step>
 <step><cmd>Right click on the <b>Session Bean</b> icon, and select <menucascade>
-<uicontrol>New</uicontrol><uicontrol>Session Bean</uicontrol></menucascade> from
-the pop-up menu.</cmd><stepresult> The <uicontrol>Create Session Bean</uicontrol> wizard
-appears.</stepresult></step>
+<uicontrol>New</uicontrol><uicontrol>Session Bean</uicontrol>
+</menucascade> from the pop-up menu.</cmd><stepresult> The <uicontrol>Create
+Session Bean</uicontrol> wizard appears.</stepresult></step>
 <step><cmd>Follow the project wizard prompts.</cmd></step>
 </steps>
 <postreq><p><b>General Information</b></p><dl><dlentry>
 <dt>State type</dt>
-<dd>There are three types of session beans: stateless, stateful and singleton. <dl><dlentry>
+<dd>There are three types of session beans: stateless, stateful and
+singleton. <dl><dlentry>
 <dt>Stateless session beans</dt>
-<dd>A stateless session bean is a collection of related services, each represented
-by a method; the bean maintains no state from one method invocation to the
-next. When you invoke a method on a stateless session bean, it executes the
-method and returns the result without knowing or caring what other requests
-have gone before or might follow. Stateless session beans have longer lives
-because they do not maintain any conversational state.</dd>
+<dd>A stateless session bean is a collection of related services,
+each represented by a method; the bean maintains no state from one
+method invocation to the next. When you invoke a method on a stateless
+session bean, it executes the method and returns the result without
+knowing or caring what other requests have gone before or might follow.
+Stateless session beans have longer lives because they do not maintain
+any conversational state.</dd>
 </dlentry><dlentry>
 <dt>Stateful session beans</dt>
-<dd>A stateful session bean performs tasks on behalf of a client and maintains
-state related to that client. This state is called conversational state because
-it represents a continuing conversation between the stateful session bean
-and the client. Methods invoked on a stateful session bean can write and read
-data to and from this conversational state, which is shared among all methods
-in the bean. Stateful session beans have timeout periods.</dd>
+<dd>A stateful session bean performs tasks on behalf of a client and
+maintains state related to that client. This state is called conversational
+state because it represents a continuing conversation between the
+stateful session bean and the client. Methods invoked on a stateful
+session bean can write and read data to and from this conversational
+state, which is shared among all methods in the bean. Stateful session
+beans have timeout periods.</dd>
 </dlentry><dlentry>
 <dt>Singleton session beans</dt>
-<dd>A Singleton session bean is a session bean component that is instantiated 
-once per application. In cases where the container is distributed over many virtual 
-machines, each application will have one bean instance of the Singleton for each JVM. 
-Once instantiated, a Singleton session bean instance lives for the duration of the 
-application in which it is created. It maintains its state between client invocations 
-but that state is not required to survive container shutdown or crash. A Singleton 
-session bean is intended to be shared and supports concurrent access.</dd>
+<dd>A Singleton session bean is a session bean component that is instantiated
+ once per application. In cases where the container is distributed
+over many virtual  machines, each application will have one bean instance
+of the Singleton for each JVM.  Once instantiated, a Singleton session
+bean instance lives for the duration of the  application in which
+it is created. It maintains its state between client invocations 
+but that state is not required to survive container shutdown or crash.
+A Singleton  session bean is intended to be shared and supports concurrent
+access.</dd>
 </dlentry></dl></dd>
 </dlentry></dl> <dl><dlentry>
 <dt>Business interface</dt>
-<dd>A business interface of a session bean is an ordinary <tm tmclass="special"
-tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> interface
-that contains the business methods for the bean. A reference to a session
-bean's business interface can be passed as a parameter or as a return value
-of a business interface method. It contains methods to initialize a session
-bean's state and to notify the EJB container when the reference is no more
-needed and can be removed. The business interfaces are two types:<dl><dlentry>
+<dd>A business interface of a session bean is an ordinary <tm
+tmclass="special" tmowner="Sun Microsystems, Inc." tmtype="tm"
+trademark="Java">Java</tm> interface that contains the business methods
+for the bean. A reference to a session bean's business interface can
+be passed as a parameter or as a return value of a business interface
+method. It contains methods to initialize a session bean's state and
+to notify the EJB container when the reference is no more needed and
+can be removed. The business interfaces are two types:<dl><dlentry>
 <dt>Remote business interface:</dt>
-<dd>The client can run on a different machine or different <tm tmclass="special"
-tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> virtual
-machine than the enterprise bean it accesses and the location of the bean
-is transparent.</dd>
+<dd>The client can run on a different machine or different <tm
+tmclass="special" tmowner="Sun Microsystems, Inc." tmtype="tm"
+trademark="Java">Java</tm> virtual machine than the enterprise bean
+it accesses and the location of the bean is transparent.</dd>
 </dlentry><dlentry>
 <dt>Local business interface:</dt>
-<dd>The client must run on the same <tm tmclass="special" tmowner="Sun Microsystems, Inc."
-tmtype="tm" trademark="Java">Java</tm> virtual machine as the bean it accesses
-and the location of the enterprise bean is not transparent.</dd>
+<dd>The client must run on the same <tm tmclass="special"
+tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> virtual
+machine as the bean it accesses and the location of the enterprise
+bean is not transparent.</dd>
 </dlentry><dlentry>
-<dt>No-interface:</dt>
-<dd>This is a variation of the Local view that exposes the public methods of the 
-bean class without the use of a separate business interface.</dd>
+<dt>No-interface View:</dt><?Pub Caret 17?>
+<dd>This is a variation of the Local view that exposes the public
+methods of the  bean class without the use of a separate business
+interface.</dd>
 </dlentry></dl></dd>
 </dlentry></dl> <dl><dlentry>
 <dt>Mapped name</dt>
 <dd>Specifies the bean's global JNDI name. The use of mappedName attribute
-allows you to assign names which you can use to search the EJB bean through
-the remote client.</dd>
+allows you to assign names which you can use to search the EJB bean
+through the remote client.</dd>
 </dlentry></dl> <dl><dlentry>
 <dt>Transaction type</dt>
-<dd>The <b>Transaction type</b> field is used to specify whether the transaction
-is handled by the <b>Container</b> or the <b>Bean</b>.</dd>
+<dd>The <b>Transaction type</b> field is used to specify whether the
+transaction is handled by the <b>Container</b> or the <b>Bean</b>.</dd>
 </dlentry></dl> <dl><dlentry>
 <dt>Home and Components Interfaces</dt>
-<dd>Home and component interfaces are used only for EJB 2.x session beans.<dl>
-<dlentry>
+<dd>Home and component interfaces are used only for EJB 2.x session
+beans.<dl><dlentry>
 <dt>Home interface:</dt>
-<dd>The home interface allows a client to create, remove and find existing
-instances of enterprise beans.</dd>
+<dd>The home interface allows a client to create, remove and find
+existing instances of enterprise beans.</dd>
 </dlentry><dlentry>
 <dt>Component interface:</dt>
-<dd>The component interface allows a client to access the business methods
-of the enterprise bean.</dd>
+<dd>The component interface allows a client to access the business
+methods of the enterprise bean.</dd>
 </dlentry></dl></dd>
 </dlentry></dl></postreq>
 </taskbody>
 </task>
+<?Pub *0000005511?>
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/tcreatingsessbeans3.html b/docs/org.eclipse.jst.ejb.doc.user/topics/tcreatingsessbeans3.html
index 7a926aa..df33cb2 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/tcreatingsessbeans3.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/tcreatingsessbeans3.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/tcreatinmessbeans3.html b/docs/org.eclipse.jst.ejb.doc.user/topics/tcreatinmessbeans3.html
index 02f6790..9ce9cdb 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/tcreatinmessbeans3.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/tcreatinmessbeans3.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/tecrte.html b/docs/org.eclipse.jst.ejb.doc.user/topics/tecrte.html
index c65527b..7fc5298 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/tecrte.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/tecrte.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/tecrtpro.html b/docs/org.eclipse.jst.ejb.doc.user/topics/tecrtpro.html
index 86a8515..b30d991 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/tecrtpro.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/tecrtpro.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/teentityb.html b/docs/org.eclipse.jst.ejb.doc.user/topics/teentityb.html
index 45ab84b..c0f71a1 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/teentityb.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/teentityb.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/teexp.html b/docs/org.eclipse.jst.ejb.doc.user/topics/teexp.html
index 1ae9472..4c395a1 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/teexp.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/teexp.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/teimp.html b/docs/org.eclipse.jst.ejb.doc.user/topics/teimp.html
index 621f8d2..2089aed 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/teimp.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/teimp.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/temessb.html b/docs/org.eclipse.jst.ejb.doc.user/topics/temessb.html
index 9c3fed5..8afd383 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/temessb.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/temessb.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/tesessb.html b/docs/org.eclipse.jst.ejb.doc.user/topics/tesessb.html
index 1e45ce2..f7877ea 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/tesessb.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/tesessb.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.jst.ejb.doc.user/topics/txdocletconf.html b/docs/org.eclipse.jst.ejb.doc.user/topics/txdocletconf.html
index 1d73a08..eeea0c8 100644
--- a/docs/org.eclipse.jst.ejb.doc.user/topics/txdocletconf.html
+++ b/docs/org.eclipse.jst.ejb.doc.user/topics/txdocletconf.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
