<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<!--
<!DOCTYPE jdoconfig
    PUBLIC "-//Sun Microsystems, Inc.//DTD Java Data Objects Configuration 3.2//EN"
    "http://xmlns.jcp.org/dtd/jdoconfig_3_2.dtd">
-->
<!ELEMENT jdoconfig (persistence-manager-factory+)>

<!ELEMENT persistence-manager-factory (property*, instance-lifecycle-listener*)>
<!ATTLIST persistence-manager-factory class CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory name CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory persistence-unit-name CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory optimistic (true|false) CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory readonly (true|false) CDATA 'false'>
<!ATTLIST persistence-manager-factory retain-values (true|false) CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory restore-values (true|false) CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory ignore-cache (true|false) CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory nontransactional-read (true|false) CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory nontransactional-write (true|false) CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory multithreaded (true|false) CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory transaction-isolation-level CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory connection-driver-name CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory connection-user-name CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory connection-password CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory connection-url CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory connection-factory-name CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory connection-factory2-name CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory mapping CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory detach-all-on-commit (true|false) CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory server-time-zone-id CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory datastore-read-timeout-millis CDATA #IMPLIED>
<!ATTLIST persistence-manager-factory datastore-write-timeout-millis CDATA #IMPLIED>

<!ELEMENT property EMPTY>
<!ATTLIST property name CDATA #REQUIRED>
<!ATTLIST property value CDATA #IMPLIED>

<!ELEMENT instance-lifecycle-listener EMPTY>
<!ATTLIST instance-lifecycle-listener listener CDATA #REQUIRED>
<!ATTLIST instance-lifecycle-listener classes CDATA #IMPLIED>
