diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..c7b7409e
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,106 @@
+# CLAUDE.md
+
+Guidance for working in this repository.
+
+## What this is
+
+`epics` is a Ruby gem implementing the [EBICS](https://www.ebics.org/) protocol
+(Electronic Banking Internet Communication Standard) — a bank-communication
+standard used mainly in Germany/France/Switzerland. It handles the key
+initialization handshake (INI / HIA / HPB), signs requests, and exchanges
+payment and statement order types with a bank's EBICS server.
+
+- Pure library gem (no Rails). Entry point: `require "epics"`.
+- Supports **EBICS 2.5 (H004, default)** and **EBICS 3.0 (H005, opt-in)**.
+- License LGPL-3.0. Published to RubyGems as `epics`.
+
+## Commands
+
+```bash
+bin/setup            # bundle install
+bundle exec rspec    # run the full test suite
+bundle exec rspec spec/client_spec.rb          # single file
+bundle exec rspec spec/client_spec.rb:42       # single example
+bin/console          # irb with the gem loaded (pry available)
+```
+
+- Ruby: developed on **3.3.7** (`.tool-versions`); CI matrix runs 3.2 / 3.3 / 3.4 / 4.0.
+- `required_ruby_version >= 3.1`.
+- CI is Semaphore (`.semaphore/semaphore.yml`) — just `bundle install` + `rspec`.
+- No linter/formatter is configured; match surrounding style.
+
+## Architecture
+
+Everything is namespaced under the `Epics` module (`Ebics` is an alias).
+`lib/epics.rb` is the manifest: it `require`s every file explicitly (no
+autoloading) and defines protocol constants (`EBICS_PROTOCOLS`, `DEFAULT_VERSION`).
+
+### The three layers
+
+1. **`Epics::Client`** (`lib/epics/client.rb`) — the public API and the only
+   object users instantiate. Holds credentials + RSA keys, exposes one method
+   per order type (`STA`, `CCT`, `CDD`, `HPB`, `HTD`, …) plus convenience
+   wrappers (`credit`, `debit`, `statements`). Owns the Faraday `connection`
+   and key encryption/decryption (AES-256-CBC over a passphrase).
+
+2. **Order classes** (`lib/epics/<order>.rb`, e.g. `sta.rb`, `cct.rb`) — one
+   small class per EBICS order type. Each subclasses `GenericRequest`
+   (downloads) or `GenericUploadRequest` (uploads) and typically only overrides
+   `#header` to declare `order_type`, `order_attribute`, and params. This is
+   the dominant pattern — to add an order type, copy the closest sibling.
+
+3. **Request builders + middleware**
+   - `generic_request.rb` / `generic_upload_request.rb` / `header_request.rb` —
+     build the EBICS XML envelope via Nokogiri.
+   - `middleware/xmlsig.rb` — Faraday middleware that signs the outgoing XML
+     (`Epics::Signer` + `signer.rb`) before it leaves.
+   - `middleware/parse_ebics.rb` — Faraday middleware that wraps every response
+     in `Epics::Response` and raises `Epics::Error::TechnicalError` /
+     `BusinessError` on non-OK return codes.
+
+### Transaction flow
+
+`Client#download` / `#upload` (near the bottom of `client.rb`) run the
+multi-step EBICS handshake: an initialization POST returns a `transaction_id`,
+followed by transfer/receipt POSTs. `download_and_unzip` additionally unpacks
+the ZIP payload (used by camt orders C52/C53/C54, Z-types, BKA…). Response
+parsing lives in `response.rb`; RSA/key handling in `key.rb`.
+
+### H004 vs H005 (important)
+
+The gem defaults to H004. H005 is selected via `Epics::Client.new(..., version: :h005)`.
+
+- `client.protocol` / `namespace` / `protocol_version` / `revision` / `h005?`
+  derive from the configured version.
+- Under H005 there is **no flat OrderTypes list** — transactions are
+  **BTF services** (`btf.rb`, `btf_mapping.rb`, `Client#services`). Generic
+  transfer is `BTU` (upload, replaces FUL) / `BTD` (download, replaces FDL).
+- Many classic order methods branch: e.g. `CCT`/`CDD`/`STA`/`C53` call
+  `btf_upload` / `btf_download` when `h005?`. When touching an order type,
+  check whether it needs an H005 branch.
+- X.509 certificate support (`x_509_certificate.rb`, `letter/ini_with_certs.erb`)
+  is part of the H005 path.
+
+### INI letter
+
+`letter_renderer.rb` renders the paper initialization letter from
+`lib/letter/*.erb`, localized via `lib/letter/locales/*.yml` (de/en/fr, i18n).
+
+## Tests
+
+- RSpec, config in `spec/spec_helper.rb` (`--require spec_helper` via `.rspec`).
+- **WebMock** stubs all HTTP — tests never hit a real bank.
+- Real EBICS responses live as fixtures in `spec/fixtures/xml/`; RSA keys/certs
+  in `spec/fixtures/*.pem` and `*.key`. Compare XML with `equivalent-xml`'s
+  `be_equivalent_to` matcher (namespace/whitespace-insensitive).
+- H005-specific coverage is in `spec/h005_client_spec.rb`.
+- Helpers/shared setup in `spec/support/`.
+
+## Conventions
+
+- One file per order type, named after the 3-letter EBICS code, lowercased
+  (`cct.rb` → `Epics::CCT`). Register new files in `lib/epics.rb`.
+- Keep order classes minimal — push shared logic into the `Generic*` base
+  classes, not into individual order types.
+- `# frozen_string_literal: true` is used on newer files; keep it when editing them.
+- Bump `Epics::VERSION` (`lib/epics/version.rb`) and update `CHANGELOG.md` for releases.
diff --git a/README.md b/README.md
index 77d6f4a6..947c2ca1 100644
--- a/README.md
+++ b/README.md
@@ -124,6 +124,44 @@ You can choose to configure some default values like this
 e = Epics::Client.new(keys, 'passphrase', 'url', 'host', 'user', 'partner', locale: :fr, product_name: 'Mon Epic Client EBICS')
 ```
 
+### EBICS 3.0 (H005)
+
+The gem defaults to EBICS 2.5 (`H004`). To use EBICS 3.0 (`H005`), pass `version: :h005`:
+
+```ruby
+e = Epics::Client.new(keys, 'passphrase', 'url', 'host', 'user', 'partner', version: :h005)
+```
+
+In EBICS 3.0 the classic order types are replaced by the Business Transaction
+Format (BTF): uploads use `BTU`, downloads use `BTD`, each described by a
+`Service` instead of a `FileFormat`.
+
+```ruby
+# Upload (replaces FUL). `service` is an Epics::BTF (or a hash with the same keys).
+e.BTU(document, Epics::BTF.new(service_name: 'SCT', scope: 'DE', msg_name: 'pain.001', msg_version: '03'))
+
+# Download (replaces FDL).
+e.BTD(Epics::BTF.new(service_name: 'EOP', scope: 'DE', container: 'ZIP', msg_name: 'camt.053', msg_version: '08'), from: '2026-01-01', to: '2026-01-31')
+```
+
+The common German convenience methods (`CCT`, `CDD`, `CDB`, `STA`, `C52`, `C53`,
+`C54`, `VMK`) automatically route to `BTU`/`BTD` via `Epics::BtfMapping` when the
+client is on `:h005`. The BTF message versions in that table are commonly-used
+defaults and **are bank-specific** — verify them against your bank's BTF mapping
+("Auftragsarten" annex) and override with the raw `BTU`/`BTD` API when needed.
+
+EBICS 3.0 requires every key to be transmitted as an X.509 certificate. For
+shared-key banks (e.g. German banks) the gem generates self-signed certificates
+automatically for `INI`/`HIA` when no certificate is supplied.
+
+> Note: All generated H005 requests (INI/HIA/HPB, the admin downloads, and
+> BTU/BTD in every transaction phase) are validated against the official H005
+> XSD schema set in the test suite, and the INI key payload against the S002
+> signature schema. Full end-to-end verification against a live H005 bank
+> endpoint is the remaining step. Known limitation: the `X509IssuerSerial`
+> currently reports the certificate version rather than its serial number
+> (pre-existing behaviour shared with the H004 X.509 path).
+
 ## Features
 
 ### Initialization
diff --git a/lib/epics.rb b/lib/epics.rb
index bf681fbd..85db7476 100644
--- a/lib/epics.rb
+++ b/lib/epics.rb
@@ -9,6 +9,33 @@
 require 'faraday'
 require 'securerandom'
 require 'time'
+
+module Epics
+  DEFAULT_PRODUCT_NAME = 'EPICS - a ruby ebics kernel'
+  DEFAULT_LOCALE = :de
+  DEFAULT_VERSION = :h004
+
+  # The electronic-signature version used for the user (bank-technical) key.
+  # This gem is A006-only: A006 (RSASSA-PSS, SHA-256) is signed by Epics::Key#sign
+  # and declared in every SignatureVersion element. A006 is valid under both
+  # H004 and H005 (which mandates it); the legacy A005 (RSA PKCS#1 v1.5) is not
+  # supported — the authentication key X002 stays PKCS#1 v1.5 on its own path.
+  SIGNATURE_VERSION = 'A006'
+
+  # EBICS protocol version descriptors. The gem defaults to H004 (EBICS 2.5) so
+  # that existing users are unaffected; H005 (EBICS 3.0) is opt-in via the
+  # `version:` client option.
+  EBICS_PROTOCOLS = {
+    h004: { namespace: 'urn:org:ebics:H004', version: 'H004', revision: '1' },
+    h005: { namespace: 'urn:org:ebics:H005', version: 'H005', revision: '1' },
+  }.freeze
+
+  # Raised when an order type is requested under an EBICS protocol version that
+  # does not support it (e.g. a classic H004 business order under H005, which
+  # expresses business transactions as BTF services instead).
+  class VersionSupportError < StandardError; end
+end
+
 require "epics/version"
 require "epics/key"
 require "epics/response"
@@ -59,15 +86,14 @@
 require "epics/hia"
 require "epics/ini"
 require "epics/hev"
+require "epics/btf"
+require "epics/btf_mapping"
+require "epics/btd"
+require "epics/btu"
 require "epics/signer"
 require "epics/x_509_certificate"
 require "epics/client"
 
 I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'letter/locales', '*.yml')]
 
-module Epics
-  DEFAULT_PRODUCT_NAME = 'EPICS - a ruby ebics kernel'
-  DEFAULT_LOCALE = :de
-end
-
 Ebics = Epics
diff --git a/lib/epics/btd.rb b/lib/epics/btd.rb
new file mode 100644
index 00000000..3703f7ae
--- /dev/null
+++ b/lib/epics/btd.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# EBICS 3.0 (H005) generic download order. Replaces the H004 FDL order: instead
+# of a FileFormat string the transfer is described by a BTF <Service>.
+#
+#   client.BTD(Epics::BTF.new(service_name: "EOP", scope: "DE", msg_name: "camt.053", msg_name_version: "08"), from: "2026-01-01", to: "2026-01-31")
+class Epics::BTD < Epics::GenericRequest
+  def header
+    client.header_request.build(
+      nonce: nonce,
+      timestamp: timestamp,
+      admin_order_type: 'BTD',
+      service: options[:service],
+      from: options[:from],
+      to: options[:to],
+      parameters: options[:parameters],
+      mutable: { TransactionPhase: 'Initialisation' }
+    )
+  end
+end
diff --git a/lib/epics/btf.rb b/lib/epics/btf.rb
new file mode 100644
index 00000000..e5d771df
--- /dev/null
+++ b/lib/epics/btf.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Value object describing an EBICS 3.0 (H005) Business Transaction Format (BTF).
+#
+# A BTF replaces the H004 OrderType/FileFormat combination. It is expressed via
+# the <Service> element inside BTU/BTD order params:
+#
+#   <Service>
+#     <ServiceName>SCT</ServiceName>
+#     <ServiceOption>...</ServiceOption>   (optional)
+#     <Scope>DE</Scope>                     (optional)
+#     <Container containerType="ZIP"/>      (optional)
+#     <MsgName version="03">pain.001</MsgName>
+#   </Service>
+#
+# Example:
+#
+#   Epics::BTF.new(
+#     service_name: "SCT",
+#     scope: "DE",
+#     msg_name: "pain.001",
+#     msg_name_version: "03",
+#   )
+#
+# A plain Hash with the same keys is accepted anywhere a BTF is expected.
+class Epics::BTF
+  attr_reader :service_name, :service_option, :scope, :container,
+              :msg_name, :msg_name_version, :msg_variant, :msg_format
+
+  def initialize(service_name:, msg_name:, scope: nil, service_option: nil,
+                 container: nil, msg_name_version: nil, msg_variant: nil, msg_format: nil)
+    @service_name   = service_name
+    @service_option = service_option
+    @scope          = scope
+    @container      = container
+    @msg_name       = msg_name
+    @msg_name_version    = msg_name_version
+    @msg_variant    = msg_variant
+    @msg_format     = msg_format
+  end
+
+  # Normalized hash consumed by Epics::HeaderRequest#build_service.
+  def to_h
+    {
+      service_name: service_name,
+      service_option: service_option,
+      scope: scope,
+      container: container,
+      msg_name: {
+        name: msg_name,
+        version: msg_name_version,
+        variant: msg_variant,
+        format: msg_format,
+      },
+    }
+  end
+end
diff --git a/lib/epics/btf_mapping.rb b/lib/epics/btf_mapping.rb
new file mode 100644
index 00000000..135d0517
--- /dev/null
+++ b/lib/epics/btf_mapping.rb
@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Maps the classic H004 order codes (CCT, CDD, C53, ...) to their EBICS 3.0
+# (H005) BTF Service descriptors, so the existing convenience API keeps working
+# when a client is configured with `version: :h005`.
+#
+# This is a *starter set* for German (DE) banks. The message versions below are
+# the commonly used ISO 20022 versions but ARE bank-specific — verify them
+# against your bank's BTF mapping / "Auftragsarten" annex and override via the
+# raw Epics::Client#BTU / #BTD API (passing an Epics::BTF) when they differ.
+#
+# Unmapped codes raise, pointing the caller at the raw BTU/BTD API.
+module Epics::BtfMapping
+  # code => btf-attributes. Message versions are only pinned where we are fairly
+  # confident of the DE default; where omitted the <MsgName> carries no version
+  # attribute and the bank applies its own default. Override per call when your
+  # bank differs (see Epics::Client convenience methods / #BTU / #BTD).
+  UPLOADS = {
+    'CCT' => { service_name: 'SCT', scope: 'DE', msg_name: 'pain.001', msg_name_version: '03' },
+    'CCS' => { service_name: 'SCT', scope: 'DE', msg_name: 'pain.001', msg_name_version: '03' },
+    'CDD' => { service_name: 'SDD', service_option: 'COR', scope: 'DE', msg_name: 'pain.008', msg_name_version: '02' },
+    'CDB' => { service_name: 'SDD', service_option: 'B2B', scope: 'DE', msg_name: 'pain.008', msg_name_version: '02' },
+    'AZV' => { service_name: 'XCT', scope: 'DE', msg_name: 'dtazv' },
+    'C2S' => { service_name: 'SDD', scope: 'BIL', msg_name: 'pain.008' },
+    'CDS' => { service_name: 'SDD', scope: 'BIL', msg_name: 'pain.008' },
+    'CIP' => { service_name: 'SCI', msg_name: 'pain.001' },
+    'XE2' => { service_name: 'MCT', msg_name: 'pain.001' },
+    'XE3' => { service_name: 'SDD', msg_name: 'pain.008' },
+  }.freeze
+
+  DOWNLOADS = {
+    'STA' => { service_name: 'EOP', scope: 'DE', msg_name: 'mt940' },
+    'C53' => { service_name: 'EOP', scope: 'DE', container: 'ZIP', msg_name: 'camt.053', msg_name_version: '08' },
+    'C52' => { service_name: 'STM', scope: 'DE', container: 'ZIP', msg_name: 'camt.052', msg_name_version: '08' },
+    'C54' => { service_name: 'REP', scope: 'DE', container: 'ZIP', msg_name: 'camt.054', msg_name_version: '08' },
+    'VMK' => { service_name: 'STM', scope: 'DE', msg_name: 'mt942' },
+    'PSR' => { service_name: 'PSR', scope: 'DE', msg_name: 'pain.002', msg_name_version: '03' },
+    'Z52' => { service_name: 'STM', container: 'ZIP', msg_name: 'camt.052' },
+    'Z53' => { service_name: 'EOP', container: 'ZIP', msg_name: 'camt.053' },
+    'Z54' => { service_name: 'EOP', service_option: 'XQRR', container: 'ZIP', msg_name: 'camt.054' },
+    'Z01' => { service_name: 'PSR', service_option: 'CH003GEN', container: 'ZIP', msg_name: 'pain.002' },
+    'BKA' => { service_name: 'EOP', scope: 'DE', container: 'ZIP', msg_name: 'camt.053' },
+    'C5N' => { service_name: 'STM', scope: 'DE', service_option: 'SCI', container: 'ZIP', msg_name: 'camt.054' },
+    'CDZ' => { service_name: 'REP', scope: 'DE', service_option: 'SDD', container: 'ZIP', msg_name: 'pain.002' },
+    'CRZ' => { service_name: 'REP', scope: 'DE', service_option: 'SCT', container: 'ZIP', msg_name: 'pain.002' },
+  }.freeze
+
+  module_function
+
+  # `overrides` lets callers replace individual BTF attributes (e.g. scope,
+  # msg_name_version, service_option) on top of the starter-set defaults, so a bank
+  # that expects a different message version or scope can be served without
+  # dropping to the raw BTU/BTD API. nil overrides are ignored.
+  def upload(code, **overrides)
+    lookup(UPLOADS, code, overrides)
+  end
+
+  def download(code, **overrides)
+    lookup(DOWNLOADS, code, overrides)
+  end
+
+  def lookup(table, code, overrides = {})
+    attrs = table[code.to_s]
+    unless attrs
+      raise ArgumentError,
+        "No H005 BTF mapping for order code #{code.inspect}. Use the raw " \
+        "Epics::Client#BTU / #BTD API with an Epics::BTF instead."
+    end
+    Epics::BTF.new(**attrs.merge(overrides.compact))
+  end
+end
diff --git a/lib/epics/btu.rb b/lib/epics/btu.rb
new file mode 100644
index 00000000..86610948
--- /dev/null
+++ b/lib/epics/btu.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# EBICS 3.0 (H005) generic upload order. Replaces the H004 FUL order: instead of
+# a FileFormat string the transfer is described by a BTF <Service>.
+#
+#   client.BTU(document, Epics::BTF.new(service_name: "SCT", scope: "DE", msg_name: "pain.001", msg_name_version: "03"))
+class Epics::BTU < Epics::GenericUploadRequest
+  def header
+    client.header_request.build(
+      nonce: nonce,
+      timestamp: timestamp,
+      admin_order_type: 'BTU',
+      service: options[:service],
+      signature_flag: options.fetch(:signature_flag, true),
+      request_eds: options[:request_eds],
+      parameters: options[:parameters],
+      mutable: { TransactionPhase: 'Initialisation' }
+    )
+  end
+end
diff --git a/lib/epics/client.rb b/lib/epics/client.rb
index c71bc300..bb1f4716 100644
--- a/lib/epics/client.rb
+++ b/lib/epics/client.rb
@@ -2,12 +2,12 @@ class Epics::Client
   extend Forwardable
 
   attr_accessor :passphrase, :url, :host_id, :user_id, :partner_id, :keys, :keys_content, :locale, :product_name,
-                :x_509_certificates_content, :debug_mode
+                :x_509_certificates_content, :debug_mode, :ebics_version
 
   attr_writer :iban, :bic, :name
-  
+
   def_delegators :connection, :post
-  
+
   def initialize(keys_content, passphrase, url, host_id, user_id, partner_id, options = {})
     self.keys_content = keys_content.respond_to?(:read) ? keys_content.read : keys_content if keys_content
     self.passphrase = passphrase
@@ -19,6 +19,10 @@ def initialize(keys_content, passphrase, url, host_id, user_id, partner_id, opti
     self.locale = options[:locale] || Epics::DEFAULT_LOCALE
     self.product_name = options[:product_name] || Epics::DEFAULT_PRODUCT_NAME
     self.debug_mode = !!options[:debug_mode]
+    self.ebics_version = (options[:version] || Epics::DEFAULT_VERSION).to_s.downcase.to_sym
+    unless Epics::EBICS_PROTOCOLS.key?(ebics_version)
+      raise ArgumentError, "Unsupported EBICS version #{ebics_version.inspect}, expected one of #{Epics::EBICS_PROTOCOLS.keys.inspect}"
+    end
     self.x_509_certificates_content = {
       a: options[:x_509_certificate_a_content],
       x: options[:x_509_certificate_x_content],
@@ -26,6 +30,26 @@ def initialize(keys_content, passphrase, url, host_id, user_id, partner_id, opti
     }
   end
 
+  def protocol
+    Epics::EBICS_PROTOCOLS.fetch(ebics_version)
+  end
+
+  def namespace
+    protocol[:namespace]
+  end
+
+  def protocol_version
+    protocol[:version]
+  end
+
+  def revision
+    protocol[:revision]
+  end
+
+  def h005?
+    ebics_version == :h005
+  end
+
   def inspect
     "#<#{self.class}:#{self.object_id}
      @keys=#{self.keys.keys},
@@ -38,7 +62,7 @@ def e
   end
 
   def a
-    keys["A006"]
+    keys[Epics::SIGNATURE_VERSION]
   end
 
   def x
@@ -49,6 +73,16 @@ def bank_e
     keys["#{host_id.upcase}.E002"]
   end
 
+  CERTIFICATE_SUFFIX = '.crt'.freeze
+
+  # X.509 certificates belonging to the user's keys, keyed like "A006.crt".
+  # Populated from the key file (entries suffixed .crt) and by generated
+  # self-signed certificates (H005); persisted alongside the keys via
+  # save_keys/dump_keys so certificates stay stable across processes.
+  def certificates
+    @certificates ||= {}
+  end
+
   def bank_x
     keys["#{host_id.upcase}.X002"]
   end
@@ -69,9 +103,15 @@ def order_types
     @order_types ||= (self.HTD; @order_types)
   end
 
+  # EBICS 3.0 (H005): the available business transactions as Epics::BTF services
+  # (there is no flat OrderTypes list anymore). Empty on H004.
+  def services
+    @services ||= (self.HTD; @services)
+  end
+
   def self.setup(passphrase, url, host_id, user_id, partner_id, keysize = 2048, options = {})
     client = new(nil, passphrase, url, host_id, user_id, partner_id, options)
-    client.keys = %w(A006 X002 E002).each_with_object({}) do |type, memo|
+    client.keys = [Epics::SIGNATURE_VERSION, 'X002', 'E002'].each_with_object({}) do |type, memo|
       memo[type] = Epics::Key.new( OpenSSL::PKey::RSA.generate(keysize) )
     end
 
@@ -123,25 +163,24 @@ def HEV
   end
 
   def HPB
-    Nokogiri::XML(download(Epics::HPB)).xpath("//xmlns:PubKeyValue", xmlns: "urn:org:ebics:H004").each do |node|
+    doc = Nokogiri::XML(download(Epics::HPB))
+    return hpb_h005(doc) if h005?
+
+    doc.xpath("//xmlns:PubKeyValue", xmlns: namespace).each do |node|
       type = node.parent.last_element_child.content
 
       modulus  = Base64.decode64(node.at_xpath(".//*[local-name() = 'Modulus']").content)
       exponent = Base64.decode64(node.at_xpath(".//*[local-name() = 'Exponent']").content)
 
-      sequence = []
-      sequence << OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(modulus, 2))
-      sequence << OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(exponent, 2))
-
-      bank = OpenSSL::PKey::RSA.new(OpenSSL::ASN1::Sequence(sequence).to_der)
-
-      self.keys["#{host_id.upcase}.#{type}"] = Epics::Key.new(bank)
+      self.keys["#{host_id.upcase}.#{type}"] = Epics::Key.new(rsa_from_modulus_exponent(modulus, exponent))
     end
 
     [bank_x, bank_e]
   end
 
-  def AZV(document)
+  def AZV(document, **overrides)
+    return btf_upload('AZV', document, **overrides) if h005?
+
     upload(Epics::AZV, document)
   end
 
@@ -149,27 +188,39 @@ def CD1(document)
     upload(Epics::CD1, document)
   end
 
-  def CDB(document)
+  def CDB(document, **overrides)
+    return btf_upload('CDB', document, **overrides) if h005?
+
     upload(Epics::CDB, document)
   end
 
-  def C2S(document)
+  def C2S(document, **overrides)
+    return btf_upload('C2S', document, **overrides) if h005?
+
     upload(Epics::C2S, document)
   end
 
-  def CDD(document)
+  def CDD(document, **overrides)
+    return btf_upload('CDD', document, **overrides) if h005?
+
     upload(Epics::CDD, document)
   end
 
-  def XE2(document)
+  def XE2(document, **overrides)
+    return btf_upload('XE2', document, **overrides) if h005?
+
     upload(Epics::XE2, document)
   end
 
-  def XE3(document)
+  def XE3(document, **overrides)
+    return btf_upload('XE3', document, **overrides) if h005?
+
     upload(Epics::XE3, document)
   end
 
-  def CDS(document)
+  def CDS(document, **overrides)
+    return btf_upload('CDS', document, **overrides) if h005?
+
     upload(Epics::CDS, document)
   end
 
@@ -177,15 +228,21 @@ def XDS(document)
     upload(Epics::XDS, document)
   end
 
-  def CCT(document)
+  def CCT(document, **overrides)
+    return btf_upload('CCT', document, **overrides) if h005?
+
     upload(Epics::CCT, document)
   end
 
-  def CIP(document)
+  def CIP(document, **overrides)
+    return btf_upload('CIP', document, **overrides) if h005?
+
     upload(Epics::CIP, document)
   end
 
-  def CCS(document)
+  def CCS(document, **overrides)
+    return btf_upload('CCS', document, **overrides) if h005?
+
     upload(Epics::CCS, document)
   end
 
@@ -197,7 +254,21 @@ def FUL(document)
     upload(Epics::FUL, document)
   end
 
-  def STA(from = nil, to = nil)
+  # EBICS 3.0 (H005) generic upload. `service` is an Epics::BTF (or a hash with
+  # the same keys). Replaces FUL under H005.
+  def BTU(document, service, signature_flag: true, request_eds: false, parameters: nil)
+    upload(Epics::BTU, document, service: service, signature_flag: signature_flag, request_eds: request_eds, parameters: parameters)
+  end
+
+  # EBICS 3.0 (H005) generic download. `service` is an Epics::BTF (or a hash with
+  # the same keys). Replaces FDL under H005.
+  def BTD(service, from: nil, to: nil, parameters: nil)
+    download(Epics::BTD, service: service, from: from, to: to, parameters: parameters)
+  end
+
+  def STA(from = nil, to = nil, **overrides)
+    return btf_download('STA', from, to, **overrides) if h005?
+
     download(Epics::STA, from: from, to: to)
   end
 
@@ -205,64 +276,104 @@ def FDL(format, from = nil, to = nil)
     download(Epics::FDL, file_format: format, from: from, to: to )
   end
 
-  def VMK(from = nil, to = nil)
+  def VMK(from = nil, to = nil, **overrides)
+    return btf_download('VMK', from, to, **overrides) if h005?
+
     download(Epics::VMK, from: from, to: to)
   end
 
-  def CDZ(from = nil, to = nil)
+  def CDZ(from = nil, to = nil, **overrides)
+    return btf_download('CDZ', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::CDZ, from: from, to: to)
   end
 
-  def CRZ(from = nil, to = nil)
+  def CRZ(from = nil, to = nil, **overrides)
+    return btf_download('CRZ', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::CRZ, from: from, to: to)
   end
 
-  def BKA(from, to)
+  def BKA(from, to, **overrides)
+    return btf_download('BKA', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::BKA, from: from, to: to)
   end
 
-  def C52(from, to)
+  def C52(from, to, **overrides)
+    return btf_download('C52', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::C52, from: from, to: to)
   end
 
-  def C53(from, to)
+  def C53(from, to, **overrides)
+    return btf_download('C53', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::C53, from: from, to: to)
   end
 
-  def C54(from, to)
+  def C54(from, to, **overrides)
+    return btf_download('C54', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::C54, from: from, to: to)
   end
 
-  def C5N(from, to)
+  def C5N(from, to, **overrides)
+    return btf_download('C5N', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::C5N, from: from, to: to)
   end
 
-  def Z01(from, to)
+  def Z01(from, to, **overrides)
+    return btf_download('Z01', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::Z01, from: from, to: to)
   end
 
-  def Z52(from, to)
+  def Z52(from, to, **overrides)
+    return btf_download('Z52', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::Z52, from: from, to: to)
   end
 
-  def Z53(from, to)
+  def Z53(from, to, **overrides)
+    return btf_download('Z53', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::Z53, from: from, to: to)
   end
 
-  def Z54(from, to)
+  def Z54(from, to, **overrides)
+    return btf_download('Z54', from, to, **overrides) if h005?
+
     download_and_unzip(Epics::Z54, from: from, to: to)
   end
 
   def HAA
-    Nokogiri::XML(download(Epics::HAA)).at_xpath("//xmlns:OrderTypes", xmlns: "urn:org:ebics:H004").content.split(/\s/)
+    doc = Nokogiri::XML(download(Epics::HAA))
+    if h005?
+      # H005: available transactions are BTF services, not a flat OrderTypes list.
+      doc.xpath("//xmlns:Service", xmlns: namespace).map { |s| service_from_node(s) }
+    else
+      doc.at_xpath("//xmlns:OrderTypes", xmlns: namespace).content.split(/\s/)
+    end
   end
 
   def HTD
     Nokogiri::XML(download(Epics::HTD)).tap do |htd|
-      @iban        ||= htd.at_xpath("//xmlns:AccountNumber[@international='true']", xmlns: "urn:org:ebics:H004").text rescue nil
-      @bic         ||= htd.at_xpath("//xmlns:BankCode[@international='true']", xmlns: "urn:org:ebics:H004").text rescue nil
-      @name        ||= htd.at_xpath("//xmlns:Name", xmlns: "urn:org:ebics:H004").text rescue nil
-      @order_types ||= htd.search("//xmlns:OrderTypes", xmlns: "urn:org:ebics:H004").map{|o| o.content.split(/\s/) }.delete_if{|o| o == ""}.flatten
+      @iban        ||= htd.at_xpath("//xmlns:AccountNumber[@international='true']", xmlns: namespace).text rescue nil
+      @bic         ||= htd.at_xpath("//xmlns:BankCode[@international='true']", xmlns: namespace).text rescue nil
+      @name        ||= htd.at_xpath("//xmlns:Name", xmlns: namespace).text rescue nil
+
+      if h005?
+        # H005 replaces OrderTypes with OrderInfo entries: each has an
+        # AdminOrderType and, for BTU/BTD, a BTF Service.
+        order_infos    = htd.search("//xmlns:OrderInfo", xmlns: namespace)
+        @order_types ||= order_infos.map { |o| o.at_xpath("./xmlns:AdminOrderType", xmlns: namespace)&.content }.compact.uniq
+        @services    ||= order_infos.map { |o| o.at_xpath("./xmlns:Service", xmlns: namespace) }.compact.map { |s| service_from_node(s) }
+      else
+        @order_types ||= htd.search("//xmlns:OrderTypes", xmlns: namespace).map{|o| o.content.split(/\s/) }.delete_if{|o| o == ""}.flatten
+        @services    ||= []
+      end
     end.to_xml
   end
 
@@ -289,24 +400,126 @@ def WSS
   def save_keys(path)
     File.write(path, dump_keys)
   end
-  
+
   def x_509_certificate(type)
     content = x_509_certificates_content[type.to_sym]
-    return if content.nil? || content.empty?
+    if content.nil? || content.empty?
+      # EBICS 3.0 mandates X.509 certificates for all keys. When none was
+      # supplied, fall back to a self-signed certificate (valid for shared-key
+      # banks, e.g. German banks). H004 keeps the raw RSAKeyValue behaviour.
+      return unless h005?
+      return self_signed_certificate(type)
+    end
     Epics::X509Certificate.new(content)
   end
-  
+
   def x_509_certificate_hash(type)
-    content = x_509_certificates_content[type.to_sym]
-    return if content.nil? || content.empty?
-    cert = OpenSSL::X509::Certificate.new(content)
-    Digest::SHA256.hexdigest(cert.to_der).upcase
+    # Routes through x_509_certificate so H005 self-signed certificates get a
+    # fingerprint too — the INI letter needs it for subscriber verification.
+    x_509_certificate(type)&.fingerprint
   end
 
   private
 
-  def upload(order_type, document)
-    order = order_type.new(self, document)
+  DSIG_NS = 'http://www.w3.org/2000/09/xmldsig#'.freeze
+
+  HPB_KEY_INFOS = {
+    'AuthenticationPubKeyInfo' => 'AuthenticationVersion',
+    'EncryptionPubKeyInfo'     => 'EncryptionVersion',
+  }.freeze
+
+  # EBICS 3.0 (H005) HPB response: the bank's authentication and encryption keys
+  # are transmitted only as X.509 certificates (ds:X509Data). Extract the public
+  # key from each certificate rather than from a PubKeyValue/RSAKeyValue.
+  def hpb_h005(doc)
+    HPB_KEY_INFOS.each do |element, version_element|
+      info = doc.at_xpath("//xmlns:#{element}", xmlns: namespace)
+      next unless info
+
+      type = info.at_xpath("./xmlns:#{version_element}", xmlns: namespace)&.content
+      next unless type
+
+      self.keys["#{host_id.upcase}.#{type}"] = Epics::Key.new(bank_key_from_info(info))
+    end
+
+    [bank_x, bank_e]
+  end
+
+  def bank_key_from_info(info)
+    cert = info.at_xpath(".//ds:X509Certificate", ds: DSIG_NS)
+    return OpenSSL::X509::Certificate.new(Base64.decode64(cert.content)).public_key if cert
+
+    # Fallback: some banks additionally include a raw RSAKeyValue.
+    modulus  = info.at_xpath(".//*[local-name() = 'Modulus']")
+    exponent = info.at_xpath(".//*[local-name() = 'Exponent']")
+    unless modulus && exponent
+      raise "HPB response: #{info.name} contains neither an X509Certificate nor an RSAKeyValue — cannot import the bank key"
+    end
+
+    rsa_from_modulus_exponent(Base64.decode64(modulus.content), Base64.decode64(exponent.content))
+  end
+
+  # Parses a BTF <Service> element (from HAA/HTD responses) into an Epics::BTF.
+  def service_from_node(node)
+    msg       = node.at_xpath("./xmlns:MsgName", xmlns: namespace)
+    container = node.at_xpath("./xmlns:Container", xmlns: namespace)
+    text = ->(name) { node.at_xpath("./xmlns:#{name}", xmlns: namespace)&.content }
+
+    Epics::BTF.new(
+      service_name:   text.call('ServiceName'),
+      scope:          text.call('Scope'),
+      service_option: text.call('ServiceOption'),
+      container:      container && (container['containerType'] || container.content),
+      msg_name:       msg&.content,
+      msg_name_version:    msg && msg['version'],
+      msg_variant:    msg && msg['variant'],
+      msg_format:     msg && msg['format'],
+    )
+  end
+
+  def rsa_from_modulus_exponent(modulus, exponent)
+    sequence = [
+      OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(modulus, 2)),
+      OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(exponent, 2)),
+    ]
+    OpenSSL::PKey::RSA.new(OpenSSL::ASN1::Sequence(sequence).to_der)
+  end
+
+  KEY_FOR_CERT_TYPE = { a: Epics::SIGNATURE_VERSION, x: 'X002', e: 'E002' }.freeze
+
+  def self_signed_certificate(type)
+    key_name = KEY_FOR_CERT_TYPE.fetch(type.to_sym)
+    key = keys[key_name]
+    return unless key
+
+    # Stored in #certificates so save_keys persists it — the certificate (and
+    # thus its fingerprint on the INI letter) must stay identical across
+    # processes, otherwise the bank cannot verify the subscriber.
+    certificates["#{key_name}#{CERTIFICATE_SUFFIX}"] ||=
+      Epics::X509Certificate.generate_self_signed(
+        key.key,
+        subject: "/CN=#{user_id}/O=#{partner_id}/OU=#{host_id}"
+      )
+  end
+
+  # Route a classic order code to its H005 BTF Service via Epics::BtfMapping.
+  # `overrides` replace individual BTF attributes (scope, msg_name_version, ...) on
+  # top of the mapped starter-set default.
+  def btf_upload(code, document, **overrides)
+    self.BTU(document, Epics::BtfMapping.upload(code, **overrides))
+  end
+
+  def btf_download(code, from, to, **overrides)
+    btf = Epics::BtfMapping.download(code, **overrides)
+    if btf.container == 'ZIP'
+      download_and_unzip(Epics::BTD, service: btf, from: from, to: to)
+    else
+      self.BTD(btf, from: from, to: to)
+    end
+  end
+
+  def upload(order_type, document, **options)
+    order = order_type.new(self, document, **options)
     res = post(url, order.to_xml).body
     order.transaction_id = res.transaction_id
 
@@ -347,13 +560,24 @@ def connection
   end
 
   def extract_keys
-    JSON.load(self.keys_content).each_with_object({}) do |(type, key), memo|
-      memo[type] = Epics::Key.new(decrypt(key)) if key
+    JSON.load(self.keys_content).each_with_object({}) do |(type, blob), memo|
+      next unless blob
+
+      # Entries suffixed with .crt are persisted X.509 certificates (H005
+      # self-signed certs survive process restarts this way); everything else
+      # is an RSA key.
+      if type.end_with?(CERTIFICATE_SUFFIX)
+        certificates[type] = Epics::X509Certificate.new(decrypt(blob))
+      else
+        memo[type] = Epics::Key.new(decrypt(blob))
+      end
     end
   end
 
   def dump_keys
-    JSON.dump(keys.each_with_object({}) {|(k,v),m| m[k]= encrypt(v.key.to_pem)})
+    data = keys.each_with_object({}) { |(k, v), m| m[k] = encrypt(v.key.to_pem) }
+    certificates.each { |k, v| data[k] = encrypt(v.to_pem) }
+    JSON.dump(data)
   end
 
   def new_cipher
diff --git a/lib/epics/generic_request.rb b/lib/epics/generic_request.rb
index 62902c5b..627ce5ad 100644
--- a/lib/epics/generic_request.rb
+++ b/lib/epics/generic_request.rb
@@ -22,6 +22,17 @@ def root
     "ebicsRequest"
   end
 
+  # Namespace/version attributes for the request root element. Derived from the
+  # client's configured EBICS protocol version (H004 by default, H005 opt-in).
+  def root_attributes
+    {
+      'xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#',
+      'xmlns' => client.namespace,
+      'Version' => client.protocol_version,
+      'Revision' => client.revision,
+    }
+  end
+
   def body
     Nokogiri::XML::Builder.new do |xml|
       xml.body
@@ -53,7 +64,7 @@ def auth_signature
 
   def to_transfer_xml
     Nokogiri::XML::Builder.new do |xml|
-      xml.send(root, 'xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#', 'xmlns' => 'urn:org:ebics:H004', 'Version' => 'H004', 'Revision' => '1') {
+      xml.send(root, root_attributes) {
         xml.header(authenticate: true) {
           xml.static {
             xml.HostID host_id
@@ -76,7 +87,7 @@ def to_transfer_xml
 
   def to_receipt_xml
     Nokogiri::XML::Builder.new do |xml|
-      xml.send(root, 'xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#', 'xmlns' => 'urn:org:ebics:H004', 'Version' => 'H004', 'Revision' => '1') {
+      xml.send(root, root_attributes) {
         xml.header(authenticate: true) {
           xml.static {
             xml.HostID host_id
@@ -98,7 +109,7 @@ def to_receipt_xml
 
   def to_xml
     Nokogiri::XML::Builder.new do |xml|
-      xml.send(root, 'xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#', 'xmlns' => 'urn:org:ebics:H004', 'Version' => 'H004', 'Revision'=> '1') {
+      xml.send(root, root_attributes) {
         xml.parent.add_child(header)
         xml.parent.add_child(auth_signature)
         xml.parent.add_child(body)
diff --git a/lib/epics/generic_upload_request.rb b/lib/epics/generic_upload_request.rb
index 8d71fdc6..b63267f0 100644
--- a/lib/epics/generic_upload_request.rb
+++ b/lib/epics/generic_upload_request.rb
@@ -27,16 +27,30 @@ def body
             xml.TransactionKey Base64.encode64(client.bank_e.key.public_encrypt(self.key)).gsub(/\n/,'')
           }
           xml.SignatureData(encrypted_order_signature, authenticate: true)
+          # EBICS 3.0 (H005) additionally carries the plain hash of the order
+          # data (the value that was signed) as a DataDigest element.
+          xml.DataDigest(data_digest, SignatureVersion: Epics::SIGNATURE_VERSION) if client.h005?
         }
       }
     end.doc.root
   end
 
+  # Base64-encoded SHA-256 digest of the order data — the same digest that is
+  # signed in #signature_value. Required in the H005 upload body.
+  def data_digest
+    Base64.strict_encode64(digester.digest(document.gsub(/\n|\r/, "")))
+  end
+
+  def signature_namespace
+    client.h005? ? 'http://www.ebics.org/S002' : 'http://www.ebics.org/S001'
+  end
+
   def order_signature
+    ns = signature_namespace
     Nokogiri::XML::Builder.new do |xml|
-      xml.UserSignatureData('xmlns' => 'http://www.ebics.org/S001', 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance', 'xsi:schemaLocation' => 'http://www.ebics.org/S001 http://www.ebics.org/S001/ebics_signature.xsd') {
+      xml.UserSignatureData('xmlns' => ns, 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance', 'xsi:schemaLocation' => "#{ns} #{ns}/ebics_signature.xsd") {
         xml.OrderSignatureData {
-          xml.SignatureVersion "A006"
+          xml.SignatureVersion Epics::SIGNATURE_VERSION
           xml.SignatureValue signature_value
           xml.PartnerID partner_id
           xml.UserID user_id
diff --git a/lib/epics/header_request.rb b/lib/epics/header_request.rb
index fc4ee043..0a6ac507 100644
--- a/lib/epics/header_request.rb
+++ b/lib/epics/header_request.rb
@@ -2,6 +2,12 @@ class Epics::HeaderRequest
   extend Forwardable
   attr_accessor :client
 
+  # Administrative order types that remain first-class order types under EBICS
+  # 3.0 (H005). Every other (business) transaction is a BTF service carried by
+  # BTU/BTD, so a classic business order code reaching the H005 builder is a
+  # caller error rather than something to silently emit as a malformed request.
+  H005_ADMIN_ORDER_TYPES = %w[HPB HTD HAA HKD HPD HAC PTK INI HIA].freeze
+
   def initialize(client)
     self.client = client
   end
@@ -21,12 +27,7 @@ def build(options = {})
           xml.UserID user_id
           xml.Product(client.product_name, 'Language' => client.locale)
           xml.OrderDetails {
-            xml.OrderType options[:order_type]
-            xml.OrderAttribute options[:order_attribute]
-            xml.StandardOrderParams {
-              build_attributes(xml, options[:order_params])
-            } if options[:order_params]
-            build_attributes(xml, options[:custom_order_params]) if options[:custom_order_params]
+            build_order_details(xml, options)
           }
           xml.BankPubKeyDigests {
             xml.Authentication(client.bank_x.public_digest, Version: 'X002', Algorithm: 'http://www.w3.org/2001/04/xmlenc#sha256')
@@ -44,6 +45,128 @@ def build(options = {})
 
   private
 
+  # EBICS 3.0 (H005) uses AdminOrderType plus a BTF Service structure, and drops
+  # OrderAttribute. EBICS 2.5 (H004) keeps the classic OrderType/OrderAttribute
+  # shape. The version branch is the only structural divergence in the header.
+  def build_order_details(xml, options)
+    if client.h005?
+      build_h005_order_details(xml, options)
+    else
+      build_h004_order_details(xml, options)
+    end
+  end
+
+  def build_h004_order_details(xml, options)
+    xml.OrderType options[:order_type]
+    xml.OrderAttribute options[:order_attribute]
+    xml.StandardOrderParams {
+      build_attributes(xml, options[:order_params])
+    } if options[:order_params]
+    build_attributes(xml, options[:custom_order_params]) if options[:custom_order_params]
+  end
+
+  def build_h005_order_details(xml, options)
+    admin_order_type = options[:admin_order_type] || options[:order_type]
+    ensure_h005_order_type!(admin_order_type)
+    xml.AdminOrderType admin_order_type
+
+    case admin_order_type
+    when 'BTU'
+      xml.BTUOrderParams {
+        build_service(xml, options[:service])
+        # SignatureFlag is an empty element (H005). Its *presence* means the
+        # order carries an electronic signature and is authorised within EBICS;
+        # omitting it means the order is authorised outside EBICS. The optional
+        # requestEDS attribute spools the order into the distributed signature
+        # (EDS/VEU) queue.
+        if options.fetch(:signature_flag, true)
+          attrs = options[:request_eds] ? { 'requestEDS' => 'true' } : {}
+          xml.SignatureFlag(attrs)
+        end
+        build_parameters(xml, options[:parameters])
+      }
+    when 'BTD'
+      xml.BTDOrderParams {
+        build_service(xml, options[:service])
+        build_date_range(xml, options)
+        build_parameters(xml, options[:parameters])
+      }
+    else
+      # Other admin order types retrieved via ebicsRequest (HTD, HAA, HKD, HPD,
+      # HAC, ...) require a StandardOrderParams element. INI/HIA/HPB use the
+      # unsecured / no-pub-key request schemas whose OrderDetails carry only the
+      # AdminOrderType, so they suppress it via with_order_params: false.
+      if options.fetch(:with_order_params, true)
+        xml.StandardOrderParams {
+          build_date_range(xml, options)
+        }
+      end
+    end
+  end
+
+  # Reject classic business order codes under H005 instead of emitting an
+  # AdminOrderType the bank will reject. BTU/BTD are the generic upload/download
+  # transports; the whitelist covers the administrative order types that survive
+  # into H005. Everything else must go through a BTF service (see Epics::BtfMapping
+  # and Epics::Client#BTU / #BTD).
+  def ensure_h005_order_type!(admin_order_type)
+    return if %w[BTU BTD].include?(admin_order_type)
+    return if H005_ADMIN_ORDER_TYPES.include?(admin_order_type)
+
+    raise Epics::VersionSupportError,
+      "Order type #{admin_order_type.inspect} is not available under EBICS 3.0 (H005). " \
+      "H005 expresses business transactions as BTF services — use Epics::Client#BTU / #BTD " \
+      "with an Epics::BTF, or add a mapping in Epics::BtfMapping. Administrative order types " \
+      "supported under H005: #{H005_ADMIN_ORDER_TYPES.join(', ')}."
+  end
+
+  # Builds the BTF <Service> element. The child element order follows the H005
+  # schema sequence: ServiceName, Scope, ServiceOption, Container, MsgName.
+  def build_service(xml, service)
+    return if service.nil?
+    service = service.to_h if service.respond_to?(:to_h)
+
+    xml.Service {
+      xml.ServiceName service[:service_name] || service[:ServiceName]
+      scope = service[:scope] || service[:Scope]
+      xml.Scope scope if scope
+      option = service[:service_option] || service[:ServiceOption]
+      xml.ServiceOption option if option
+
+      container = service[:container] || service[:Container]
+      if container
+        xml.Container('containerType' => container)
+      end
+
+      msg = service[:msg_name] || service[:MsgName] || {}
+      msg = { name: msg } unless msg.is_a?(Hash)
+      msg_attrs = {}
+      msg_attrs['version'] = msg[:version] if msg[:version]
+      msg_attrs['variant'] = msg[:variant] if msg[:variant]
+      msg_attrs['format']  = msg[:format]  if msg[:format]
+      xml.MsgName(msg[:name] || msg[:value], msg_attrs)
+    }
+  end
+
+  def build_date_range(xml, options)
+    if options[:from] && options[:to]
+      xml.DateRange {
+        xml.Start options[:from]
+        xml.End options[:to]
+      }
+    end
+  end
+
+  def build_parameters(xml, parameters)
+    return if parameters.nil?
+    parameters.each do |name, value|
+      xml.Parameter {
+        xml.Name name
+        xml.Value(value, 'Type' => 'string')
+      }
+    end
+  end
+
   def build_attributes(xml, attributes)
     attributes.each do |key, value|
       if value.is_a?(Hash)
diff --git a/lib/epics/hia.rb b/lib/epics/hia.rb
index f43879dc..8ea6b27f 100644
--- a/lib/epics/hia.rb
+++ b/lib/epics/hia.rb
@@ -6,8 +6,10 @@ def root
   def header
     client.header_request.build(
       order_type: 'HIA',
+      admin_order_type: 'HIA',
       order_attribute: 'DZNNN',
       with_bank_pubkey_digests: false,
+      with_order_params: false,
       mutable: {}
     )
   end
@@ -23,8 +25,10 @@ def body
   end
 
   def order_data
+    return h005_order_data if client.h005?
+
     Nokogiri::XML::Builder.new do |xml|
-      xml.HIARequestOrderData('xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#', 'xmlns' => 'urn:org:ebics:H004') {
+      xml.HIARequestOrderData('xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#', 'xmlns' => client.namespace) {
         xml.AuthenticationPubKeyInfo {
           x509_data_xml(xml, client.x_509_certificate(:x))
           xml.PubKeyValue {
@@ -51,9 +55,28 @@ def order_data
     end.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML, encoding: 'utf-8')
   end
 
+  # EBICS 3.0 (H005): public keys are carried exclusively as X.509 certificates
+  # (ds:X509Data); the H004 RSAKeyValue is no longer part of the structure.
+  def h005_order_data
+    Nokogiri::XML::Builder.new do |xml|
+      xml.HIARequestOrderData('xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#', 'xmlns' => client.namespace) {
+        xml.AuthenticationPubKeyInfo {
+          x509_data_xml(xml, client.x_509_certificate(:x))
+          xml.AuthenticationVersion 'X002'
+        }
+        xml.EncryptionPubKeyInfo {
+          x509_data_xml(xml, client.x_509_certificate(:e))
+          xml.EncryptionVersion 'E002'
+        }
+        xml.PartnerID partner_id
+        xml.UserID user_id
+      }
+    end.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML, encoding: 'utf-8')
+  end
+
   def to_xml
     Nokogiri::XML::Builder.new do |xml|
-      xml.send(root, 'xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#', 'xmlns' => 'urn:org:ebics:H004', 'Version' => 'H004', 'Revision' => '1') {
+      xml.send(root, root_attributes) {
         xml.parent.add_child(header)
         xml.parent.add_child(body)
       }
diff --git a/lib/epics/hpb.rb b/lib/epics/hpb.rb
index 48d1abe0..b6dc20e8 100644
--- a/lib/epics/hpb.rb
+++ b/lib/epics/hpb.rb
@@ -8,8 +8,10 @@ def header
       nonce: nonce,
       timestamp: timestamp,
       order_type: 'HPB',
+      admin_order_type: 'HPB',
       order_attribute: 'DZHNN',
       with_bank_pubkey_digests: false,
+      with_order_params: false,
       mutable: {}
     )
   end
diff --git a/lib/epics/ini.rb b/lib/epics/ini.rb
index 40e7ea16..1946e316 100644
--- a/lib/epics/ini.rb
+++ b/lib/epics/ini.rb
@@ -6,8 +6,10 @@ def root
   def header
     client.header_request.build(
       order_type: 'INI',
+      admin_order_type: 'INI',
       order_attribute: 'DZNNN',
       with_bank_pubkey_digests: false,
+      with_order_params: false,
       mutable: {},
     )
   end
@@ -23,6 +25,8 @@ def body
   end
 
   def key_signature
+    return h005_key_signature if client.h005?
+
     Nokogiri::XML::Builder.new do |xml|
       xml.SignaturePubKeyOrderData('xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#', 'xmlns' => 'http://www.ebics.org/S001') {
         xml.SignaturePubKeyInfo {
@@ -34,7 +38,23 @@ def key_signature
             }
             xml.TimeStamp timestamp
           }
-          xml.SignatureVersion 'A006'
+          xml.SignatureVersion Epics::SIGNATURE_VERSION
+        }
+        xml.PartnerID partner_id
+        xml.UserID user_id
+      }
+    end.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML, encoding: 'utf-8')
+  end
+
+  # EBICS 3.0 (H005): the signature namespace is S002 and the public key is
+  # carried exclusively as an X.509 certificate (ds:X509Data) — the H004
+  # RSAKeyValue is no longer part of the structure.
+  def h005_key_signature
+    Nokogiri::XML::Builder.new do |xml|
+      xml.SignaturePubKeyOrderData('xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#', 'xmlns' => 'http://www.ebics.org/S002') {
+        xml.SignaturePubKeyInfo {
+          x509_data_xml(xml, client.x_509_certificate(:a))
+          xml.SignatureVersion Epics::SIGNATURE_VERSION
         }
         xml.PartnerID partner_id
         xml.UserID user_id
@@ -44,7 +64,7 @@ def key_signature
 
   def to_xml
     Nokogiri::XML::Builder.new do |xml|
-      xml.send(root, 'xmlns:ds' => 'http://www.w3.org/2000/09/xmldsig#', 'xmlns' => 'urn:org:ebics:H004', 'Version' => 'H004', 'Revision' => '1') {
+      xml.send(root, root_attributes) {
         xml.parent.add_child(header)
         xml.parent.add_child(body)
       }
diff --git a/lib/epics/letter_renderer.rb b/lib/epics/letter_renderer.rb
index 7bd788e0..480ebfa7 100644
--- a/lib/epics/letter_renderer.rb
+++ b/lib/epics/letter_renderer.rb
@@ -31,12 +31,24 @@ def use_x_509_certificate_template?
   def x_509_certificate_a_hash
     @client.x_509_certificate_hash(:a)
   end
-  
+
   def x_509_certificate_x_hash
     @client.x_509_certificate_hash(:x)
   end
-  
+
   def x_509_certificate_e_hash
     @client.x_509_certificate_hash(:e)
   end
+
+  def x_509_certificate_a_pem
+    @client.x_509_certificate(:a)&.to_pem
+  end
+
+  def x_509_certificate_x_pem
+    @client.x_509_certificate(:x)&.to_pem
+  end
+
+  def x_509_certificate_e_pem
+    @client.x_509_certificate(:e)&.to_pem
+  end
 end
diff --git a/lib/epics/response.rb b/lib/epics/response.rb
index 7ac98736..0126fefe 100644
--- a/lib/epics/response.rb
+++ b/lib/epics/response.rb
@@ -7,6 +7,12 @@ def initialize(client, xml)
     self.client = client
   end
 
+  # EBICS protocol namespace of the configured client (H004 by default, H005
+  # when opted in). All response XPaths are scoped to this namespace.
+  def ns
+    client ? client.namespace : Epics::EBICS_PROTOCOLS.fetch(Epics::DEFAULT_VERSION)[:namespace]
+  end
+
   def technical_error?
     !["011000", "000000"].include?(technical_code)
   end
@@ -16,7 +22,7 @@ def technical_code
   end
 
   def mutable_return_code
-    doc.xpath("//xmlns:header/xmlns:mutable/xmlns:ReturnCode", xmlns: "urn:org:ebics:H004").text
+    doc.xpath("//xmlns:header/xmlns:mutable/xmlns:ReturnCode", xmlns: ns).text
   end
 
   def system_return_code
@@ -28,7 +34,7 @@ def business_error?
   end
 
   def business_code
-    doc.xpath("//xmlns:body/xmlns:ReturnCode", xmlns: "urn:org:ebics:H004").text
+    doc.xpath("//xmlns:body/xmlns:ReturnCode", xmlns: ns).text
   end
 
   def ok?
@@ -36,29 +42,29 @@ def ok?
   end
 
   def last_segment?
-    !!doc.at_xpath("//xmlns:header/xmlns:mutable/*[@lastSegment='true']", xmlns: "urn:org:ebics:H004")
+    !!doc.at_xpath("//xmlns:header/xmlns:mutable/*[@lastSegment='true']", xmlns: ns)
   end
 
   def segmented?
-    !!doc.at_xpath("//xmlns:header/xmlns:mutable/xmlns:SegmentNumber", xmlns: "urn:org:ebics:H004")
+    !!doc.at_xpath("//xmlns:header/xmlns:mutable/xmlns:SegmentNumber", xmlns: ns)
   end
 
   def return_code
-    doc.xpath("//xmlns:ReturnCode", xmlns: "urn:org:ebics:H004").last.content
+    doc.xpath("//xmlns:ReturnCode", xmlns: ns).last.content
   rescue NoMethodError
     nil
   end
 
   def report_text
-    doc.xpath("//xmlns:ReportText", xmlns: "urn:org:ebics:H004").first.content
+    doc.xpath("//xmlns:ReportText", xmlns: ns).first.content
   end
 
   def transaction_id
-    doc.xpath("//xmlns:header/xmlns:static/xmlns:TransactionID", xmlns: 'urn:org:ebics:H004').text
+    doc.xpath("//xmlns:header/xmlns:static/xmlns:TransactionID", xmlns: ns).text
   end
 
   def order_id
-    doc.xpath("//xmlns:header/xmlns:mutable/xmlns:OrderID", xmlns: "urn:org:ebics:H004").text
+    doc.xpath("//xmlns:header/xmlns:mutable/xmlns:OrderID", xmlns: ns).text
   end
 
   def digest_valid?
@@ -78,13 +84,13 @@ def signature_valid?
   end
 
   def public_digest_valid?
-    encryption_pub_key_digest = doc.xpath("//xmlns:EncryptionPubKeyDigest", xmlns: 'urn:org:ebics:H004').first
+    encryption_pub_key_digest = doc.xpath("//xmlns:EncryptionPubKeyDigest", xmlns: ns).first
 
     client.e.public_digest == encryption_pub_key_digest.content
   end
 
   def order_data
-    order_data_encrypted = Base64.decode64(doc.xpath("//xmlns:OrderData", xmlns: 'urn:org:ebics:H004').first.content)
+    order_data_encrypted = Base64.decode64(doc.xpath("//xmlns:OrderData", xmlns: ns).first.content)
 
     data = (cipher.update(order_data_encrypted) + cipher.final)
 
@@ -101,7 +107,7 @@ def cipher
   end
 
   def transaction_key
-    transaction_key_encrypted = Base64.decode64(doc.xpath("//xmlns:TransactionKey", xmlns: 'urn:org:ebics:H004').first.content)
+    transaction_key_encrypted = Base64.decode64(doc.xpath("//xmlns:TransactionKey", xmlns: ns).first.content)
 
     @transaction_key ||= client.e.key.private_decrypt(transaction_key_encrypted)
   end
diff --git a/lib/epics/x_509_certificate.rb b/lib/epics/x_509_certificate.rb
index 1eacaed6..8119b8d1 100644
--- a/lib/epics/x_509_certificate.rb
+++ b/lib/epics/x_509_certificate.rb
@@ -3,13 +3,43 @@ class Epics::X509Certificate
 
   attr_reader :certificate
 
-  def_delegators :certificate, :issuer, :version
+  def_delegators :certificate, :issuer, :version, :serial, :to_pem
 
   def initialize(crt_content)
-    @certificate = OpenSSL::X509::Certificate.new(crt_content)
+    @certificate =
+      if crt_content.is_a?(OpenSSL::X509::Certificate)
+        crt_content
+      else
+        OpenSSL::X509::Certificate.new(crt_content)
+      end
   end
 
   def data
     Base64.strict_encode64(@certificate.to_der)
   end
-end
\ No newline at end of file
+
+  # SHA-256 fingerprint of the DER-encoded certificate (upper-case hex), as
+  # printed on the EBICS 3.0 INI letter.
+  def fingerprint
+    Digest::SHA256.hexdigest(@certificate.to_der).upcase
+  end
+
+  # Generates a self-signed X.509 certificate wrapping the given RSA key. EBICS
+  # 3.0 (H005) requires every public key to be transmitted as an X.509
+  # certificate; for banks using the shared-key model (e.g. German banks) a
+  # self-signed certificate is sufficient.
+  def self.generate_self_signed(rsa_key, subject:, valid_years: 10)
+    cert = OpenSSL::X509::Certificate.new
+    cert.version = 2
+    cert.serial = OpenSSL::BN.new(Digest::SHA256.hexdigest(rsa_key.n.to_s(16))[0, 16].to_i(16))
+    name = OpenSSL::X509::Name.parse(subject)
+    cert.subject = name
+    cert.issuer = name
+    cert.public_key = rsa_key.public_key
+    cert.not_before = Time.now
+    cert.not_after = Time.now + (valid_years * 365 * 24 * 60 * 60)
+    cert.sign(rsa_key, OpenSSL::Digest::SHA256.new)
+
+    new(cert)
+  end
+end
diff --git a/lib/letter/ini_with_certs.erb b/lib/letter/ini_with_certs.erb
index c5bdde16..ca180676 100644
--- a/lib/letter/ini_with_certs.erb
+++ b/lib/letter/ini_with_certs.erb
@@ -109,7 +109,7 @@
     </tr>
   </table>
   <p><%= t('certificate') %> :</p>
-  <pre class="code"><code><%= @client.x_509_certificates_content[:a] %></code></pre>
+  <pre class="code"><code><%= x_509_certificate_a_pem %></code></pre>
   <p><%= t('hash') %> (SHA-256) :</p>
   <p class="code"><code><%= x_509_certificate_a_hash.scan(/../).join(":") %></code></p>
   <p><%= t('confirmation') %></p>
@@ -218,7 +218,7 @@
     </tr>
   </table>
   <p><%= t('certificate') %> :</p>
-  <pre class="code"><code><%= @client.x_509_certificates_content[:x] %></code></pre>
+  <pre class="code"><code><%= x_509_certificate_x_pem %></code></pre>
   <p><%= t('hash') %> (SHA-256) :</p>
   <p class="code"><code><%= x_509_certificate_x_hash.scan(/../).join(":") %></code></p>
 </div>
@@ -298,7 +298,7 @@
     </tr>
   </table>
   <p><%= t('certificate') %> :</p>
-  <pre class="code"><code><%= @client.x_509_certificates_content[:e] %></code></pre>
+  <pre class="code"><code><%= x_509_certificate_e_pem %></code></pre>
   <p><%= t('hash') %> (SHA-256) :</p>
   <p class="code"><code><%= x_509_certificate_e_hash.scan(/../).join(":") %></code></p>
   <p><%= t('confirmation') %></p>
diff --git a/spec/btf_spec.rb b/spec/btf_spec.rb
new file mode 100644
index 00000000..e94dc0fd
--- /dev/null
+++ b/spec/btf_spec.rb
@@ -0,0 +1,71 @@
+RSpec.describe Epics::BTF do
+  it 'normalizes attributes into the service hash consumed by HeaderRequest' do
+    btf = described_class.new(
+      service_name: 'SCT', scope: 'DE', service_option: 'URG',
+      container: 'ZIP', msg_name: 'pain.001', msg_name_version: '03', msg_variant: '001'
+    )
+
+    expect(btf.to_h).to eq(
+      service_name: 'SCT',
+      service_option: 'URG',
+      scope: 'DE',
+      container: 'ZIP',
+      msg_name: { name: 'pain.001', version: '03', variant: '001', format: nil }
+    )
+  end
+end
+
+RSpec.describe Epics::BtfMapping do
+  it 'maps a known upload code to a BTF' do
+    btf = described_class.upload('CCT')
+    expect(btf).to be_a(Epics::BTF)
+    expect(btf.service_name).to eq('SCT')
+    expect(btf.msg_name).to eq('pain.001')
+  end
+
+  it 'maps a known download code to a BTF' do
+    btf = described_class.download('C53')
+    expect(btf.service_name).to eq('EOP')
+    expect(btf.container).to eq('ZIP')
+    expect(btf.msg_name).to eq('camt.053')
+  end
+
+  it 'maps the extended upload set (XE2/AZV/CIP/...)' do
+    expect(described_class.upload('XE2').service_name).to eq('MCT')
+    expect(described_class.upload('AZV').msg_name).to eq('dtazv')
+    expect(described_class.upload('CIP').service_name).to eq('SCI')
+    expect(described_class.upload('C2S').scope).to eq('BIL')
+  end
+
+  it 'maps the extended download set (Z53/BKA/CDZ/...)' do
+    expect(described_class.download('Z53').service_name).to eq('EOP')
+    expect(described_class.download('Z53').container).to eq('ZIP')
+    expect(described_class.download('CDZ').service_option).to eq('SDD')
+    expect(described_class.download('CRZ').service_option).to eq('SCT')
+    expect(described_class.download('C5N').service_option).to eq('SCI')
+  end
+
+  it 'raises a helpful error for unmapped codes' do
+    expect { described_class.upload('ZZZ') }.to raise_error(ArgumentError, /raw/)
+  end
+
+  it 'still raises for codes with no H005 form (CD1/FUL/XCT/XDS)' do
+    %w[CD1 FUL XCT XDS].each do |code|
+      expect { described_class.upload(code) }.to raise_error(ArgumentError)
+    end
+  end
+
+  it 'applies overrides on top of the mapped defaults' do
+    btf = described_class.download('C53', scope: 'CH', msg_name_version: '04')
+    expect(btf.service_name).to eq('EOP')   # default kept
+    expect(btf.msg_name).to eq('camt.053')  # default kept
+    expect(btf.scope).to eq('CH')           # overridden
+    expect(btf.msg_name_version).to eq('04')     # overridden
+  end
+
+  it 'ignores nil overrides, keeping the mapped default' do
+    btf = described_class.download('C53', scope: nil, msg_name_version: nil)
+    expect(btf.scope).to eq('DE')
+    expect(btf.msg_name_version).to eq('08')
+  end
+end
diff --git a/spec/h005_client_spec.rb b/spec/h005_client_spec.rb
new file mode 100644
index 00000000..9e93ba44
--- /dev/null
+++ b/spec/h005_client_spec.rb
@@ -0,0 +1,331 @@
+RSpec.describe 'EBICS 3.0 (H005) client' do
+  let(:client) do
+    Epics::Client.new(
+      File.open(File.join(File.dirname(__FILE__), 'fixtures', 'SIZBN001.key')),
+      'secret', 'https://example.com', 'SIZBN001', 'EBIX', 'EBICS',
+      version: :h005
+    )
+  end
+
+  describe 'version wiring' do
+    it { expect(client.ebics_version).to eq(:h005) }
+    it { expect(client.namespace).to eq('urn:org:ebics:H005') }
+    it { expect(client.protocol_version).to eq('H005') }
+    it { expect(client).to be_h005 }
+
+    it 'defaults to H004 when no version is given' do
+      c = Epics::Client.new(nil, 'secret', 'https://example.com', 'H', 'U', 'P')
+      expect(c.ebics_version).to eq(:h004)
+      expect(c.namespace).to eq('urn:org:ebics:H004')
+      expect(c).not_to be_h005
+    end
+
+    it 'rejects unknown versions' do
+      expect {
+        Epics::Client.new(nil, 'secret', 'https://example.com', 'H', 'U', 'P', version: :h006)
+      }.to raise_error(ArgumentError, /Unsupported EBICS version/)
+    end
+  end
+
+  describe 'admin order types' do
+    it { expect(Epics::HPB.new(client).to_xml).to include('<AdminOrderType>HPB</AdminOrderType>') }
+    it { expect(Epics::HTD.new(client).to_xml).to include('<AdminOrderType>HTD</AdminOrderType>') }
+    it { expect(Epics::HPB.new(client).to_xml).not_to include('OrderAttribute') }
+
+    context 'XSD validity', if: ebics_xsd_available?(:h005) do
+      %i[HPB HTD HAA HKD HPD].each do |ot|
+        it "#{ot} is a valid H005 document" do
+          expect(Epics.const_get(ot).new(client).to_xml).to be_a_valid_ebics_doc(:h005)
+        end
+      end
+
+      it 'INI is a valid H005 document' do
+        expect(Epics::INI.new(client).to_xml).to be_a_valid_ebics_doc(:h005)
+      end
+
+      it 'HIA is a valid H005 document' do
+        expect(Epics::HIA.new(client).to_xml).to be_a_valid_ebics_doc(:h005)
+      end
+    end
+  end
+
+  describe 'key management embeds X.509 certificates (mandatory in H005)' do
+    it 'embeds a self-signed cert in HIA order data' do
+      data = Epics::HIA.new(client).order_data
+      expect(data).to include('urn:org:ebics:H005')
+      expect(data).to include('X509Certificate')
+    end
+
+    it 'embeds a self-signed cert in the INI signature order data' do
+      expect(Epics::INI.new(client).key_signature).to include('X509Certificate')
+    end
+
+    it 'generates a certificate for each key type' do
+      %i[a x e].each { |t| expect(client.x_509_certificate(t)).to be_a(Epics::X509Certificate) }
+    end
+
+    it 'uses the S002 signature namespace and no RSAKeyValue' do
+      sig = Epics::INI.new(client).key_signature
+      expect(sig).to include('http://www.ebics.org/S002')
+      expect(sig).not_to include('RSAKeyValue')
+    end
+
+    it 'renders the INI letter with the self-signed certificate fingerprints' do
+      letter = client.ini_letter('Testbank')
+      fingerprint = client.x_509_certificate_hash(:a).scan(/../).join(':')
+
+      expect(letter).to include(fingerprint)
+      expect(letter).to include('BEGIN CERTIFICATE')
+    end
+
+    it 'persists self-signed certificates across dump_keys/extract_keys round trips' do
+      fingerprint = client.x_509_certificate(:a).fingerprint
+
+      reloaded = Epics::Client.new(
+        client.send(:dump_keys), 'secret', 'https://example.com', 'SIZBN001', 'EBIX', 'EBICS',
+        version: :h005
+      )
+
+      expect(reloaded.x_509_certificate(:a).fingerprint).to eq(fingerprint)
+    end
+
+    it 'does not leak certificate entries into the RSA key set' do
+      client.x_509_certificate(:a)
+
+      reloaded = Epics::Client.new(
+        client.send(:dump_keys), 'secret', 'https://example.com', 'SIZBN001', 'EBIX', 'EBICS',
+        version: :h005
+      )
+
+      expect(reloaded.keys.keys).not_to include(a_string_ending_with('.crt'))
+      expect(reloaded.certificates.keys).to include('A006.crt')
+    end
+
+    context 'S002 XSD validity', if: ebics_xsd_available?(:h005) do
+      let(:s002) do
+        Nokogiri::XML::Schema(File.open(File.join(File.dirname(__FILE__), 'xsd', 'ebics_signature_S002.xsd')))
+      end
+
+      it 'INI signature order data validates against S002' do
+        errors = s002.validate(Nokogiri::XML(Epics::INI.new(client).key_signature))
+        expect(errors).to be_empty
+      end
+    end
+  end
+
+  describe 'HPB imports bank keys from X.509 certificates (H005)' do
+    let(:bank_auth) { OpenSSL::PKey::RSA.generate(2048) }
+    let(:bank_enc)  { OpenSSL::PKey::RSA.generate(2048) }
+
+    def cert_data(rsa)
+      Epics::X509Certificate.generate_self_signed(rsa, subject: '/CN=bank').data
+    end
+
+    let(:hpb_response) do
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <HPBResponseOrderData xmlns="urn:org:ebics:H005" xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
+          <AuthenticationPubKeyInfo>
+            <ds:X509Data><ds:X509Certificate>#{cert_data(bank_auth)}</ds:X509Certificate></ds:X509Data>
+            <AuthenticationVersion>X002</AuthenticationVersion>
+            <ext:Extra xmlns:ext="urn:example:ext">allowed by the schema's any-wildcard</ext:Extra>
+          </AuthenticationPubKeyInfo>
+          <EncryptionPubKeyInfo>
+            <ds:X509Data><ds:X509Certificate>#{cert_data(bank_enc)}</ds:X509Certificate></ds:X509Data>
+            <EncryptionVersion>E002</EncryptionVersion>
+          </EncryptionPubKeyInfo>
+          <HostID>SIZBN001</HostID>
+        </HPBResponseOrderData>
+      XML
+    end
+
+    before { allow(client).to receive(:download).with(Epics::HPB).and_return(hpb_response) }
+
+    it 'stores the bank authentication key (X002) from its certificate' do
+      client.HPB
+      expect(client.bank_x).to be_a(Epics::Key)
+      expect(client.bank_x.key.n).to eq(bank_auth.n)
+    end
+
+    it 'stores the bank encryption key (E002) from its certificate' do
+      client.HPB
+      expect(client.bank_e).to be_a(Epics::Key)
+      expect(client.bank_e.key.n).to eq(bank_enc.n)
+    end
+
+    context 'when a PubKeyInfo carries neither certificate nor RSAKeyValue' do
+      let(:hpb_response) do
+        <<~XML
+          <?xml version="1.0" encoding="UTF-8"?>
+          <HPBResponseOrderData xmlns="urn:org:ebics:H005" xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
+            <AuthenticationPubKeyInfo>
+              <AuthenticationVersion>X002</AuthenticationVersion>
+            </AuthenticationPubKeyInfo>
+            <EncryptionPubKeyInfo>
+              <EncryptionVersion>E002</EncryptionVersion>
+            </EncryptionPubKeyInfo>
+            <HostID>SIZBN001</HostID>
+          </HPBResponseOrderData>
+        XML
+      end
+
+      it 'raises a descriptive error' do
+        expect { client.HPB }.to raise_error(/neither an X509Certificate nor an RSAKeyValue/)
+      end
+    end
+  end
+
+  describe 'HAA lists available BTF services (H005)' do
+    let(:haa_response) do
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <HAAResponseOrderData xmlns="urn:org:ebics:H005">
+          <Service>
+            <ServiceName>EOP</ServiceName>
+            <Scope>DE</Scope>
+            <Container containerType="ZIP"/>
+            <MsgName version="08">camt.053</MsgName>
+          </Service>
+          <Service>
+            <ServiceName>SCT</ServiceName>
+            <MsgName version="03">pain.001</MsgName>
+          </Service>
+        </HAAResponseOrderData>
+      XML
+    end
+
+    before { allow(client).to receive(:download).with(Epics::HAA).and_return(haa_response) }
+
+    it 'returns parsed BTF services' do
+      services = client.HAA
+      expect(services.map(&:service_name)).to eq(%w[EOP SCT])
+      expect(services.first.container).to eq('ZIP')
+      expect(services.first.msg_name).to eq('camt.053')
+      expect(services.first.msg_name_version).to eq('08')
+    end
+  end
+
+  describe 'HTD parses account data and BTF services (H005)' do
+    let(:htd_response) do
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <HTDResponseOrderData xmlns="urn:org:ebics:H005">
+          <PartnerInfo>
+            <AddressInfo><Name>ACME Corp</Name></AddressInfo>
+            <BankInfo><HostID>SIZBN001</HostID></BankInfo>
+            <AccountInfo ID="1">
+              <AccountNumber international="true">DE89370400440532013000</AccountNumber>
+              <BankCode international="true">COBADEFFXXX</BankCode>
+            </AccountInfo>
+            <OrderInfo>
+              <AdminOrderType>BTD</AdminOrderType>
+              <Service>
+                <ServiceName>EOP</ServiceName>
+                <Scope>DE</Scope>
+                <Container containerType="ZIP"/>
+                <MsgName version="08">camt.053</MsgName>
+              </Service>
+              <Description>Statements</Description>
+            </OrderInfo>
+            <OrderInfo>
+              <AdminOrderType>BTU</AdminOrderType>
+              <Service>
+                <ServiceName>SCT</ServiceName>
+                <MsgName version="03">pain.001</MsgName>
+              </Service>
+              <Description>Credit transfer</Description>
+            </OrderInfo>
+            <OrderInfo>
+              <AdminOrderType>HAC</AdminOrderType>
+              <Description>Acknowledgement</Description>
+            </OrderInfo>
+          </PartnerInfo>
+          <UserInfo/>
+        </HTDResponseOrderData>
+      XML
+    end
+
+    before { allow(client).to receive(:download).with(Epics::HTD).and_return(htd_response) }
+
+    it 'parses name, iban and bic' do
+      expect(client.name).to eq('ACME Corp')
+      expect(client.iban).to eq('DE89370400440532013000')
+      expect(client.bic).to eq('COBADEFFXXX')
+    end
+
+    it 'exposes distinct admin order types' do
+      expect(client.order_types).to eq(%w[BTD BTU HAC])
+    end
+
+    it 'exposes the BTF services' do
+      expect(client.services.map(&:service_name)).to eq(%w[EOP SCT])
+      expect(client.services.first.msg_name).to eq('camt.053')
+    end
+  end
+
+  describe 'convenience methods route to BTU/BTD under H005' do
+    it 'CCT builds a BTU with the SCT service' do
+      order = Epics::BTU.new(client, '<Document/>', service: Epics::BtfMapping.upload('CCT'))
+      expect(order.header.to_s).to include('<AdminOrderType>BTU</AdminOrderType>')
+      expect(order.header.to_s).to include('<ServiceName>SCT</ServiceName>')
+    end
+
+    it 'passes per-call overrides through to the rendered BTD Service' do
+      btf = Epics::BtfMapping.download('C53', scope: 'CH', msg_name_version: '04')
+      header = Epics::BTD.new(client, service: btf).header.to_s
+      expect(header).to include('<ServiceName>EOP</ServiceName>')
+      expect(header).to include('<Scope>CH</Scope>')
+      expect(header).to include('<MsgName version="04">camt.053</MsgName>')
+    end
+  end
+
+  describe 'rejects classic business orders that have no H005 form' do
+    it 'raises VersionSupportError instead of emitting a malformed order' do
+      expect { Epics::WSS.new(client).to_xml }
+        .to raise_error(Epics::VersionSupportError, /not available under EBICS 3.0/)
+    end
+
+    it 'names the raw BTU/BTD escape hatch in the message' do
+      expect { Epics::FUL.new(client, '<Document/>').to_xml }
+        .to raise_error(Epics::VersionSupportError, /BTU.*BTD|BtfMapping/)
+    end
+
+    it 'still allows administrative order types (HTD)' do
+      expect { Epics::HTD.new(client).to_xml }.not_to raise_error
+    end
+  end
+
+  describe 'extended convenience methods route to BTU/BTD under H005' do
+    it 'XE2 builds a BTU with the MCT service' do
+      order = Epics::BTU.new(client, '<Document/>', service: Epics::BtfMapping.upload('XE2'))
+      expect(order.header.to_s).to include('<AdminOrderType>BTU</AdminOrderType>')
+      expect(order.header.to_s).to include('<ServiceName>MCT</ServiceName>')
+    end
+
+    it 'Z53 builds a BTD with the EOP service' do
+      order = Epics::BTD.new(client, service: Epics::BtfMapping.download('Z53'))
+      expect(order.header.to_s).to include('<AdminOrderType>BTD</AdminOrderType>')
+      expect(order.header.to_s).to include('<ServiceName>EOP</ServiceName>')
+    end
+  end
+end
+
+RSpec.describe 'EBICS 2.5 (H004) remains the default and unchanged' do
+  let(:client) do
+    Epics::Client.new(
+      File.open(File.join(File.dirname(__FILE__), 'fixtures', 'SIZBN001.key')),
+      'secret', 'https://example.com', 'SIZBN001', 'EBIX', 'EBICS'
+    )
+  end
+
+  it 'still emits the classic OrderType/OrderAttribute shape' do
+    header = Epics::CCT.new(client, '<Document/>').header.to_s
+    expect(header).to include('<OrderType>CCT</OrderType>')
+    expect(header).to include('<OrderAttribute>OZHNN</OrderAttribute>')
+    expect(header).not_to include('AdminOrderType')
+  end
+
+  it 'does not auto-embed X.509 certificates' do
+    expect(Epics::HIA.new(client).order_data).not_to include('X509Certificate')
+  end
+end
diff --git a/spec/orders/btd_spec.rb b/spec/orders/btd_spec.rb
new file mode 100644
index 00000000..f3ed4c2b
--- /dev/null
+++ b/spec/orders/btd_spec.rb
@@ -0,0 +1,42 @@
+RSpec.describe Epics::BTD do
+  let(:client) do
+    Epics::Client.new(
+      File.open(File.join(File.dirname(__FILE__), '..', 'fixtures', 'SIZBN001.key')),
+      'secret', 'https://194.180.18.30/ebicsweb/ebicsweb', 'SIZBN001', 'EBIX', 'EBICS',
+      version: :h005
+    )
+  end
+
+  let(:service) do
+    Epics::BTF.new(service_name: 'EOP', scope: 'DE', container: 'ZIP', msg_name: 'camt.053', msg_name_version: '08')
+  end
+
+  subject(:order) { described_class.new(client, service: service, from: '2026-01-01', to: '2026-01-31') }
+
+  describe 'H005 envelope' do
+    it { expect(order.to_xml).to include('xmlns="urn:org:ebics:H005"') }
+    it { expect(order.to_xml).to include('Version="H005"') }
+  end
+
+  describe 'OrderDetails / BTF' do
+    let(:header) { order.header.to_s }
+
+    it { expect(header).to include('<AdminOrderType>BTD</AdminOrderType>') }
+    it { expect(header).to include('<BTDOrderParams>') }
+    it { expect(header).to include('<ServiceName>EOP</ServiceName>') }
+    it { expect(header).to include('<Scope>DE</Scope>') }
+    it { expect(header).to include('<Container containerType="ZIP"/>') }
+    it { expect(header).to include('<MsgName version="08">camt.053</MsgName>') }
+    it { expect(header).to match(%r{<DateRange>\s*<Start>2026-01-01</Start>\s*<End>2026-01-31</End>\s*</DateRange>}) }
+    it { expect(header).not_to include('OrderAttribute') }
+  end
+
+  describe '#to_xml' do
+    specify { expect(order.to_xml).to be_a_valid_ebics_doc(:h005) } if ebics_xsd_available?(:h005)
+  end
+
+  describe '#to_receipt_xml' do
+    before { order.transaction_id = SecureRandom.hex(16) }
+    it { expect(order.to_receipt_xml).to include('xmlns="urn:org:ebics:H005"') }
+  end
+end
diff --git a/spec/orders/btu_spec.rb b/spec/orders/btu_spec.rb
new file mode 100644
index 00000000..8ec11dbe
--- /dev/null
+++ b/spec/orders/btu_spec.rb
@@ -0,0 +1,59 @@
+RSpec.describe Epics::BTU do
+  let(:client) do
+    Epics::Client.new(
+      File.open(File.join(File.dirname(__FILE__), '..', 'fixtures', 'SIZBN001.key')),
+      'secret', 'https://194.180.18.30/ebicsweb/ebicsweb', 'SIZBN001', 'EBIX', 'EBICS',
+      version: :h005
+    )
+  end
+
+  let(:document) { File.read(File.join(File.dirname(__FILE__), '..', 'fixtures', 'xml', 'cd1.xml')) }
+  let(:service) do
+    Epics::BTF.new(service_name: 'SCT', scope: 'DE', msg_name: 'pain.001', msg_name_version: '03')
+  end
+
+  subject(:order) { described_class.new(client, document, service: service) }
+
+  describe 'H005 envelope' do
+    it { expect(order.to_xml).to include('xmlns="urn:org:ebics:H005"') }
+    it { expect(order.to_xml).to include('Version="H005"') }
+  end
+
+  describe 'OrderDetails / BTF' do
+    let(:header) { order.header.to_s }
+
+    it { expect(header).to include('<AdminOrderType>BTU</AdminOrderType>') }
+    it { expect(header).to include('<BTUOrderParams>') }
+    it { expect(header).to include('<ServiceName>SCT</ServiceName>') }
+    it { expect(header).to include('<MsgName version="03">pain.001</MsgName>') }
+    it { expect(header).to match(%r{<SignatureFlag\s*/>}) }
+    it { expect(header).not_to include('OrderAttribute') }
+  end
+
+  describe 'signature flag' do
+    it 'omits SignatureFlag when the order carries no ES' do
+      order = described_class.new(client, document, service: service, signature_flag: false)
+      expect(order.header.to_s).not_to include('SignatureFlag')
+    end
+
+    it 'adds requestEDS for distributed signature' do
+      order = described_class.new(client, document, service: service, request_eds: true)
+      expect(order.header.to_s).to include('requestEDS="true"')
+    end
+  end
+
+  describe 'H005 upload body' do
+    it 'includes a DataDigest with the A006 signature version' do
+      expect(order.to_xml).to match(%r{<DataDigest SignatureVersion="A006">.+</DataDigest>})
+    end
+  end
+
+  describe '#to_xml' do
+    specify { expect(order.to_xml).to be_a_valid_ebics_doc(:h005) } if ebics_xsd_available?(:h005)
+  end
+
+  describe '#to_transfer_xml' do
+    before { order.transaction_id = SecureRandom.hex(16) }
+    it { expect(order.to_transfer_xml).to include('xmlns="urn:org:ebics:H005"') }
+  end
+end
diff --git a/spec/support/ebics_matcher.rb b/spec/support/ebics_matcher.rb
index 86c9bef6..44499fcd 100644
--- a/spec/support/ebics_matcher.rb
+++ b/spec/support/ebics_matcher.rb
@@ -1,22 +1,38 @@
-RSpec::Matchers.define :be_a_valid_ebics_doc do
+# Root schema per EBICS protocol version. Drop the official H005 schema set into
+# spec/xsd/ (ebics_H005.xsd + its includes) to enable H005 validation.
+EBICS_XSD_ROOT = {
+  h004: 'ebics_H004.xsd',
+  h005: 'ebics_H005.xsd',
+}.freeze
+
+def ebics_xsd_path(version)
+  File.join(File.dirname(__FILE__), '..', 'xsd', EBICS_XSD_ROOT.fetch(version))
+end
+
+# True when the XSD schema set for the given EBICS version is available locally.
+def ebics_xsd_available?(version)
+  File.exist?(ebics_xsd_path(version))
+end
+
+RSpec::Matchers.define :be_a_valid_ebics_doc do |version = :h004|
 
   ##
   # use #open instead of #read to have the includes working
   # http://stackoverflow.com/questions/11996326/nokogirixmlschema-syntaxerror-on-schema-load/22971456#22971456
-  def xsd
-    @xsd ||= Nokogiri::XML::Schema(File.open( File.join( File.dirname(__FILE__), '..', 'xsd', 'ebics_H004.xsd') ))
+  def xsd(version)
+    @xsd ||= Nokogiri::XML::Schema(File.open(ebics_xsd_path(version)))
   end
 
   match do |actual|
-    xsd.valid?(Nokogiri::XML(actual))
+    xsd(version).valid?(Nokogiri::XML(actual))
   end
 
   failure_message do |actual|
-    "expected that #{actual} would be a valid EBICS doc:\n\n #{xsd.validate(Nokogiri::XML(actual))}"
+    "expected that #{actual} would be a valid EBICS doc:\n\n #{xsd(version).validate(Nokogiri::XML(actual))}"
   end
 
   description do
     "be a valid EBICS document"
   end
 
-end
\ No newline at end of file
+end
diff --git a/spec/xsd/ebics_H005.xsd b/spec/xsd/ebics_H005.xsd
new file mode 100644
index 00000000..149bf263
--- /dev/null
+++ b/spec/xsd/ebics_H005.xsd
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:ebics="urn:org:ebics:H005" targetNamespace="urn:org:ebics:H005" elementFormDefault="qualified" attributeFormDefault="unqualified" version="1.0">
+	<annotation>
+		<documentation xml:lang="de">ebics_H005.xsd inkludiert alle Schemadateien des EBICS-Protokolls, um die Eindeutigkeit von Element- und Typnamen im EBCIS Namespace zu erzwingen.</documentation>
+		<documentation xml:lang="en">ebics_H005.xsd includes all schema files for the EBICS protocol in order to enforce unique element and type names in the EBICS namespace.</documentation>
+	</annotation>
+	<include schemaLocation="ebics_request_H005.xsd"/>
+	<include schemaLocation="ebics_response_H005.xsd"/>
+	<include schemaLocation="ebics_keymgmt_request_H005.xsd"/>
+	<include schemaLocation="ebics_keymgmt_response_H005.xsd"/>
+</schema>
diff --git a/spec/xsd/ebics_keymgmt_request_H005.xsd b/spec/xsd/ebics_keymgmt_request_H005.xsd
new file mode 100644
index 00000000..cb93d3c4
--- /dev/null
+++ b/spec/xsd/ebics_keymgmt_request_H005.xsd
@@ -0,0 +1,523 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- edited with XMLSpy v2016 sp1 (x64) (http://www.altova.com) by EBICS Working Group - October 2016 -->
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:ebics="urn:org:ebics:H005" targetNamespace="urn:org:ebics:H005" elementFormDefault="qualified" attributeFormDefault="unqualified" version="1.0">
+	<annotation>
+		<documentation xml:lang="de">ebics_keymgmt_request_H005.xsd ist das EBICS-Protokollschema für Schlüsselmanagement-Anfragen (HIA, HPB, HSA, INI).</documentation>
+	</annotation>
+	<import namespace="http://www.w3.org/2000/09/xmldsig#" schemaLocation="xmldsig-core-schema.xsd">
+		<annotation>
+			<documentation xml:lang="de">XML-Signature.</documentation>
+		</annotation>
+	</import>
+	<include schemaLocation="ebics_types_H005.xsd"/>
+	<include schemaLocation="ebics_orders_H005.xsd"/>
+	<complexType name="StaticHeaderBaseType" abstract="true">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den statischen EBICS-Header (allgemein).</documentation>
+		</annotation>
+		<sequence>
+			<element name="HostID" type="ebics:HostIDType">
+				<annotation>
+					<documentation xml:lang="de">Hostname des Banksystems.</documentation>
+				</annotation>
+			</element>
+			<element name="Nonce" type="ebics:NonceType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Zufallswert; damit wird die Initialisierungsnachricht des Clients einzigartig; nur anzugeben, falls Authentifikationssignatur vorhanden.</documentation>
+				</annotation>
+			</element>
+			<element name="Timestamp" type="ebics:TimestampType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">aktueller Zeitstempel zur Begrenzung der serverseitigen Nonce-Speicherung; nur anzugeben, falls Authentifikationssignatur vorhanden.</documentation>
+				</annotation>
+			</element>
+			<element name="PartnerID" type="ebics:PartnerIDType">
+				<annotation>
+					<documentation xml:lang="de">Kunden-ID des serverseitig administrierten Kunden.</documentation>
+				</annotation>
+			</element>
+			<element name="UserID" type="ebics:UserIDType">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmer-ID des serverseitig zu diesem Kunden administrierten Teilnehmers.</documentation>
+				</annotation>
+			</element>
+			<element name="SystemID" type="ebics:UserIDType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">technische User-ID für Multi-User-Systeme.</documentation>
+				</annotation>
+			</element>
+			<element name="Product" type="ebics:ProductElementType" nillable="true" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Kennung des Kundenprodukts bzw. Herstellerkennung oder Name.</documentation>
+				</annotation>
+			</element>
+			<element name="OrderDetails" type="ebics:OrderDetailsType">
+				<annotation>
+					<documentation xml:lang="de">Auftragsdetails.</documentation>
+				</annotation>
+			</element>
+			<element name="SecurityMedium" type="ebics:SecurityMediumType">
+				<annotation>
+					<documentation xml:lang="de">Angabe des Sicherheitsmediums, das der Kunde verwendet.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="OrderDetailsType" abstract="true">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für OrderDetails im statischen EBICS-Header (allgemein).</documentation>
+		</annotation>
+		<sequence>
+			<element name="AdminOrderType" type="ebics:OrderTBaseType">
+				<annotation>
+					<documentation xml:lang="de">Auftragsart.</documentation>
+				</annotation>
+			</element>
+		</sequence>
+	</complexType>
+	<complexType name="ProductElementType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Element mit Kennung des Kundenprodukts bzw. Herstellerkennung oder Name.</documentation>
+		</annotation>
+		<simpleContent>
+			<extension base="ebics:ProductType">
+				<attribute name="Language" type="ebics:LanguageType" use="required">
+					<annotation>
+						<documentation xml:lang="de">Sprachkennzeichen der Kundenproduktversion (gemäß ISO 639).</documentation>
+					</annotation>
+				</attribute>
+				<attribute name="InstituteID" type="ebics:InstituteIDType" use="optional">
+					<annotation>
+						<documentation xml:lang="de">Kennung des Herausgebers des Kundenprodukts bzw. des betreuenden Kreditinstituts.</documentation>
+					</annotation>
+				</attribute>
+			</extension>
+		</simpleContent>
+	</complexType>
+	<complexType name="EmptyMutableHeaderType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den leeren variablen EBICS-Header von Key Managemen Aufträgen.</documentation>
+		</annotation>
+		<sequence>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<element name="ebicsUnsecuredRequest">
+		<annotation>
+			<documentation>Anfragestruktur für ungesicherte Auftragsarten HIA (Authentifikations- und Verschlüsselungsschlüssel senden) und INI (bankfachllichen Schlüssel senden).</documentation>
+		</annotation>
+		<complexType>
+			<sequence>
+				<element name="header">
+					<annotation>
+						<documentation xml:lang="de">enthält die technischen Transaktionsdaten.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<element name="static" type="ebics:UnsecuredRequestStaticHeaderType">
+								<annotation>
+									<documentation xml:lang="de">enhält alle festen Headereinträge.</documentation>
+								</annotation>
+							</element>
+							<element name="mutable" type="ebics:EmptyMutableHeaderType">
+								<annotation>
+									<documentation xml:lang="de">enthält alle variablen Headereinträge.</documentation>
+								</annotation>
+							</element>
+						</sequence>
+						<attributeGroup ref="ebics:AuthenticationMarker"/>
+					</complexType>
+				</element>
+				<element name="body">
+					<annotation>
+						<documentation xml:lang="de">enthält die Auftragsdaten.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<annotation>
+								<documentation xml:lang="de"/>
+							</annotation>
+							<element name="DataTransfer">
+								<annotation>
+									<documentation xml:lang="de">Transfer von Auftragsdaten.</documentation>
+								</annotation>
+								<complexType>
+									<sequence>
+										<element name="OrderData">
+											<annotation>
+												<documentation xml:lang="de">enthält Auftragsdaten.</documentation>
+											</annotation>
+											<complexType>
+												<simpleContent>
+													<extension base="ebics:OrderDataType">
+														<anyAttribute namespace="##targetNamespace" processContents="lax"/>
+													</extension>
+												</simpleContent>
+											</complexType>
+										</element>
+									</sequence>
+								</complexType>
+							</element>
+						</sequence>
+					</complexType>
+				</element>
+			</sequence>
+			<attributeGroup ref="ebics:VersionAttrGroup"/>
+		</complexType>
+	</element>
+	<complexType name="UnsecuredRequestStaticHeaderType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den statischen EBICS-Header bei ungesicherten Sendeauftragsarten (Aufträge HIA und INI): kein Nonce, kein Timestamp, keine EU-Datei, keine X001 Authentifizierung, keine Verschlüsselung, keine Digests der öffentlichen Bankschlüssel, Nutzdaten komprimiert</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:StaticHeaderBaseType">
+				<sequence>
+					<element name="HostID" type="ebics:HostIDType">
+						<annotation>
+							<documentation xml:lang="de">Hostname des Banksystems.</documentation>
+						</annotation>
+					</element>
+					<element name="Nonce" type="ebics:NonceType" minOccurs="0" maxOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">Zufallswert; damit wird die Initialisierungsnachricht des Clients einzigartig; nicht anzugeben für ebicsUnsecuredRequest.</documentation>
+						</annotation>
+					</element>
+					<element name="Timestamp" type="ebics:TimestampType" minOccurs="0" maxOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">aktueller Zeitstempel zur Begrenzung der serverseitigen Nonce-Speicherung; nicht anzugeben für ebicsUnsecuredRequest.</documentation>
+						</annotation>
+					</element>
+					<element name="PartnerID" type="ebics:PartnerIDType">
+						<annotation>
+							<documentation xml:lang="de">Kunden-ID des serverseitig administrierten Kunden.</documentation>
+						</annotation>
+					</element>
+					<element name="UserID" type="ebics:UserIDType">
+						<annotation>
+							<documentation xml:lang="de">Teilnehmer-ID des serverseitig zu diesem Kunden administrierten Teilnehmers.</documentation>
+						</annotation>
+					</element>
+					<element name="SystemID" type="ebics:UserIDType" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">technische User-ID für Multi-User-Systeme.</documentation>
+						</annotation>
+					</element>
+					<element name="Product" type="ebics:ProductElementType" nillable="true" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">Kennung des Kundenprodukts bzw. Herstellerkennung oder Name.</documentation>
+						</annotation>
+					</element>
+					<element name="OrderDetails" type="ebics:UnsecuredReqOrderDetailsType">
+						<annotation>
+							<documentation xml:lang="de">Auftragsdetails.</documentation>
+						</annotation>
+					</element>
+					<element name="SecurityMedium" type="ebics:SecurityMediumType">
+						<annotation>
+							<documentation xml:lang="de">Angabe des Sicherheitsmediums, das der Kunde verwendet.</documentation>
+						</annotation>
+					</element>
+					<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+				</sequence>
+			</restriction>
+		</complexContent>
+	</complexType>
+	<complexType name="UnsecuredReqOrderDetailsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für OrderDetails im statischen EBICS-Header von ebicsUnsecuredRequest.</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:OrderDetailsType">
+				<sequence>
+					<element name="AdminOrderType" type="ebics:OrderTBaseType">
+						<annotation>
+							<documentation xml:lang="de">Auftragsart.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</restriction>
+		</complexContent>
+	</complexType>
+	<element name="ebicsNoPubKeyDigestsRequest">
+		<annotation>
+			<documentation>Anfragestruktur für Auftragsarten ohne Übertragung der Digests der öffentlichen Bankschlüssel (HPB Bankschlüssel abholen).</documentation>
+		</annotation>
+		<complexType>
+			<sequence>
+				<element name="header">
+					<annotation>
+						<documentation xml:lang="de">enthält die technischen Transaktionsdaten.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<element name="static" type="ebics:NoPubKeyDigestsRequestStaticHeaderType">
+								<annotation>
+									<documentation xml:lang="de">enhält alle festen Headereinträge.</documentation>
+								</annotation>
+							</element>
+							<element name="mutable" type="ebics:EmptyMutableHeaderType">
+								<annotation>
+									<documentation xml:lang="de">enthält alle variablen Headereinträge.</documentation>
+								</annotation>
+							</element>
+						</sequence>
+						<attributeGroup ref="ebics:AuthenticationMarker"/>
+					</complexType>
+				</element>
+				<element ref="ebics:AuthSignature">
+					<annotation>
+						<documentation xml:lang="de">Authentifikationssignatur.</documentation>
+					</annotation>
+				</element>
+				<element name="body">
+					<annotation>
+						<documentation xml:lang="de">enthält optionale Zertifikate (vorgesehen).</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<annotation>
+								<documentation xml:lang="de"/>
+							</annotation>
+							<element ref="ds:X509Data" minOccurs="0" maxOccurs="0">
+								<annotation>
+									<documentation xml:lang="de">X.509-Daten des Teilnehmers.</documentation>
+								</annotation>
+							</element>
+						</sequence>
+					</complexType>
+				</element>
+			</sequence>
+			<attributeGroup ref="ebics:VersionAttrGroup"/>
+		</complexType>
+	</element>
+	<complexType name="NoPubKeyDigestsRequestStaticHeaderType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den statischen EBICS-Header bei Aufträgen ohne Übertragung der Digests der Bankschlüssel (Auftrag HBP): keine Digests der öffentlichen Bankschlüssel, keine EU-Datei, keine Nutzdaten, OrderId optional!, Nonce, Timestamp, X001 Authentifizierung, Auftragsattribut DZHNN</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:StaticHeaderBaseType">
+				<sequence>
+					<element name="HostID" type="ebics:HostIDType">
+						<annotation>
+							<documentation xml:lang="de">Hostname des Banksystems.</documentation>
+						</annotation>
+					</element>
+					<element name="Nonce" type="ebics:NonceType">
+						<annotation>
+							<documentation xml:lang="de">Zufallswert; damit wird die Initialisierungsnachricht des Clients einzigartig.</documentation>
+						</annotation>
+					</element>
+					<element name="Timestamp" type="ebics:TimestampType">
+						<annotation>
+							<documentation xml:lang="de">aktueller Zeitstempel zur Begrenzung der serverseitigen Nonce-Speicherung.</documentation>
+						</annotation>
+					</element>
+					<element name="PartnerID" type="ebics:PartnerIDType">
+						<annotation>
+							<documentation xml:lang="de">Kunden-ID des serverseitig administrierten Kunden.</documentation>
+						</annotation>
+					</element>
+					<element name="UserID" type="ebics:UserIDType">
+						<annotation>
+							<documentation xml:lang="de">Teilnehmer-ID des serverseitig zu diesem Kunden administrierten Teilnehmers.</documentation>
+						</annotation>
+					</element>
+					<element name="SystemID" type="ebics:UserIDType" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">technische User-ID für Multi-User-Systeme.</documentation>
+						</annotation>
+					</element>
+					<element name="Product" type="ebics:ProductElementType" nillable="true" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">Kennung des Kundenprodukts bzw. Herstellerkennung oder Name.</documentation>
+						</annotation>
+					</element>
+					<element name="OrderDetails" type="ebics:NoPubKeyDigestsReqOrderDetailsType">
+						<annotation>
+							<documentation xml:lang="de">Auftragsdetails.</documentation>
+						</annotation>
+					</element>
+					<element name="SecurityMedium" type="ebics:SecurityMediumType">
+						<annotation>
+							<documentation xml:lang="de">Angabe des Sicherheitsmediums, das der Kunde verwendet.</documentation>
+						</annotation>
+					</element>
+					<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+				</sequence>
+			</restriction>
+		</complexContent>
+	</complexType>
+	<complexType name="NoPubKeyDigestsReqOrderDetailsType">
+		<annotation>
+			<documentation xml:lang="de"> Datentyp für OrderDetails im statischen EBICS-Header von ebicsNoPubKeyDigestsRequest.</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:OrderDetailsType">
+				<sequence>
+					<element name="AdminOrderType" type="ebics:OrderTBaseType">
+						<annotation>
+							<documentation xml:lang="de">Auftragsart.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</restriction>
+		</complexContent>
+	</complexType>
+	<element name="ebicsUnsignedRequest">
+		<annotation>
+			<documentation xml:lang="en">The structure for uploads contains order data and the ESs, but without an authentication signature and data digest of bank keys.</documentation>
+			<documentation>Anfragestruktur für Sendeaufträge mit EU-Datei und Nutzdaten aber ohne Authentifizierungssignatur und Digests der Bankschlüssel.</documentation>
+		</annotation>
+		<complexType>
+			<sequence>
+				<element name="header">
+					<annotation>
+						<documentation xml:lang="en">Contains technical transaction data.</documentation>
+						<documentation xml:lang="de">enthält die technischen Transaktionsdaten.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<element name="static" type="ebics:UnsignedRequestStaticHeaderType">
+								<annotation>
+									<documentation xml:lang="en">Contains all fixed header entries.</documentation>
+									<documentation xml:lang="de">enhält alle festen Headereinträge.</documentation>
+								</annotation>
+							</element>
+							<element name="mutable" type="ebics:EmptyMutableHeaderType">
+								<annotation>
+									<documentation xml:lang="en">Contains all mutable header entries.</documentation>
+									<documentation xml:lang="de">enthält alle variablen Headereinträge.</documentation>
+								</annotation>
+							</element>
+						</sequence>
+						<attributeGroup ref="ebics:AuthenticationMarker"/>
+					</complexType>
+				</element>
+				<element name="body">
+					<annotation>
+						<documentation xml:lang="en">Contains the order data and the ESs.</documentation>
+						<documentation xml:lang="de">enthält die Auftragsdaten und EUs.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<annotation>
+								<documentation xml:lang="de"/>
+							</annotation>
+							<element name="DataTransfer">
+								<annotation>
+									<documentation xml:lang="en">Transfer of order data and the ESs.</documentation>
+									<documentation xml:lang="de">Transfer von Auftragsdaten und EUs.</documentation>
+								</annotation>
+								<complexType>
+									<sequence>
+										<element name="SignatureData">
+											<annotation>
+												<documentation xml:lang="en">Contains the ESs.</documentation>
+												<documentation xml:lang="de">enthält Signaturdaten (EUs).</documentation>
+											</annotation>
+											<complexType>
+												<simpleContent>
+													<extension base="ebics:SignatureDataType">
+														<attributeGroup ref="ebics:AuthenticationMarker"/>
+													</extension>
+												</simpleContent>
+											</complexType>
+										</element>
+										<element name="OrderData">
+											<annotation>
+												<documentation xml:lang="en">Contains the order data</documentation>
+												<documentation xml:lang="de">enthält Auftragsdaten.</documentation>
+											</annotation>
+											<complexType>
+												<simpleContent>
+													<extension base="ebics:OrderDataType">
+														<anyAttribute namespace="##targetNamespace" processContents="lax"/>
+													</extension>
+												</simpleContent>
+											</complexType>
+										</element>
+									</sequence>
+								</complexType>
+							</element>
+						</sequence>
+					</complexType>
+				</element>
+			</sequence>
+			<attributeGroup ref="ebics:VersionAttrGroup"/>
+		</complexType>
+	</element>
+	<complexType name="UnsignedRequestStaticHeaderType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den statischen EBICS-Header für ebicsUnsignedRequest.Datentyp für den statischen EBICS-Header bei Aufträgen ohne Authentifizierungssignatur (Auftrag HSA): keine X001 Authentifizierung, keine Digests der öffentlichen Bankschlüssel, EU-Datei, Nutzdaten, Nonce, Timestamp, OrderId, Auftragsattribut OZNNN</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:StaticHeaderBaseType">
+				<sequence>
+					<element name="HostID" type="ebics:HostIDType">
+						<annotation>
+							<documentation xml:lang="de">Hostname des Banksystems.</documentation>
+						</annotation>
+					</element>
+					<element name="Nonce" type="ebics:NonceType" minOccurs="0" maxOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">Zufallswert; damit wird die Initialisierungsnachricht des Clients einzigartig; nicht anzugeben bei ebicsUnsignedRequest.</documentation>
+						</annotation>
+					</element>
+					<element name="Timestamp" type="ebics:TimestampType" minOccurs="0" maxOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">aktueller Zeitstempel zur Begrenzung der serverseitigen Nonce-Speicherung; nicht anzugeben bei ebicsUnsignedRequest.</documentation>
+						</annotation>
+					</element>
+					<element name="PartnerID" type="ebics:PartnerIDType">
+						<annotation>
+							<documentation xml:lang="de">Kunden-ID des serverseitig administrierten Kunden.</documentation>
+						</annotation>
+					</element>
+					<element name="UserID" type="ebics:UserIDType">
+						<annotation>
+							<documentation xml:lang="de">Teilnehmer-ID des serverseitig zu diesem Kunden administrierten Teilnehmers.</documentation>
+						</annotation>
+					</element>
+					<element name="SystemID" type="ebics:UserIDType" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">technische User-ID für Multi-User-Systeme.</documentation>
+						</annotation>
+					</element>
+					<element name="Product" type="ebics:ProductElementType" nillable="true" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">Kennung des Kundenprodukts bzw. Herstellerkennung oder Name.</documentation>
+						</annotation>
+					</element>
+					<element name="OrderDetails" type="ebics:UnsignedReqOrderDetailsType">
+						<annotation>
+							<documentation xml:lang="de">Auftragsdetails.</documentation>
+						</annotation>
+					</element>
+					<element name="SecurityMedium" type="ebics:SecurityMediumType">
+						<annotation>
+							<documentation xml:lang="de">Angabe des Sicherheitsmediums, das der Kunde verwendet.</documentation>
+						</annotation>
+					</element>
+					<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+				</sequence>
+			</restriction>
+		</complexContent>
+	</complexType>
+	<complexType name="UnsignedReqOrderDetailsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für OrderDetails im statischen EBICS-Header von ebicsUnsignedRequest.</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:OrderDetailsType">
+				<sequence>
+					<element name="AdminOrderType" type="ebics:OrderTBaseType">
+						<annotation>
+							<documentation xml:lang="de">Auftragsart.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</restriction>
+		</complexContent>
+	</complexType>
+</schema>
diff --git a/spec/xsd/ebics_keymgmt_response_H005.xsd b/spec/xsd/ebics_keymgmt_response_H005.xsd
new file mode 100644
index 00000000..dfc33909
--- /dev/null
+++ b/spec/xsd/ebics_keymgmt_response_H005.xsd
@@ -0,0 +1,137 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- edited with XMLSpy v2016 sp1 (x64) (http://www.altova.com) by EBICS Working Group - October 2016 -->
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:ebics="urn:org:ebics:H005" targetNamespace="urn:org:ebics:H005" elementFormDefault="qualified" attributeFormDefault="unqualified" version="1.0">
+	<annotation>
+		<documentation xml:lang="de">ebics_keymgmt_response_H005.xsd ist das EBICS-Protokollschema für Schlüsselmanagement-Antwortnachrichten (HIA, HPB, HSA, INI).</documentation>
+	</annotation>
+	<import namespace="http://www.w3.org/2000/09/xmldsig#" schemaLocation="xmldsig-core-schema.xsd">
+		<annotation>
+			<documentation xml:lang="de">XML-Signature.</documentation>
+		</annotation>
+	</import>
+	<include schemaLocation="ebics_types_H005.xsd"/>
+	<include schemaLocation="ebics_orders_H005.xsd"/>
+	<element name="ebicsKeyManagementResponse">
+		<annotation>
+			<documentation xml:lang="de">Electronic Banking Internet Communication Standard des Zentralen Kreditausschusses (ZKA): Multibankfähige Schnittstelle zur internetbasierten Kommunikation.</documentation>
+		</annotation>
+		<complexType>
+			<sequence>
+				<element name="header">
+					<annotation>
+						<documentation xml:lang="de">enthält die technischen Transaktionsdaten.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<element name="static">
+								<annotation>
+									<documentation xml:lang="de">enhält alle festen Headereinträge.</documentation>
+								</annotation>
+								<complexType>
+									<sequence/>
+								</complexType>
+							</element>
+							<element name="mutable" type="ebics:KeyMgmntResponseMutableHeaderType">
+								<annotation>
+									<documentation xml:lang="de">enthält alle variablen Headereinträge.</documentation>
+								</annotation>
+							</element>
+						</sequence>
+						<attributeGroup ref="ebics:AuthenticationMarker"/>
+					</complexType>
+				</element>
+				<element name="body">
+					<annotation>
+						<documentation xml:lang="de">enthält die Auftragsdaten und den fachlichen ReturnCode.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<element name="DataTransfer" minOccurs="0">
+								<annotation>
+									<documentation xml:lang="de">Transfer von Auftragsdaten; nur bei Download anzugeben (HPB).</documentation>
+								</annotation>
+								<complexType>
+									<sequence>
+										<element name="DataEncryptionInfo">
+											<annotation>
+												<documentation xml:lang="de">Informationen zur Verschlüsselung der Auftragsdaten</documentation>
+											</annotation>
+											<complexType>
+												<complexContent>
+													<extension base="ebics:DataEncryptionInfoType">
+														<attributeGroup ref="ebics:AuthenticationMarker"/>
+													</extension>
+												</complexContent>
+											</complexType>
+										</element>
+										<element name="OrderData">
+											<annotation>
+												<documentation xml:lang="de">enthält Auftragsdaten.</documentation>
+											</annotation>
+											<complexType>
+												<simpleContent>
+													<extension base="ebics:OrderDataType">
+														<anyAttribute namespace="##targetNamespace" processContents="lax"/>
+													</extension>
+												</simpleContent>
+											</complexType>
+										</element>
+										<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+									</sequence>
+								</complexType>
+							</element>
+							<element name="ReturnCode">
+								<annotation>
+									<documentation xml:lang="de">Antwortcode für den vorangegangenen Transfer.</documentation>
+								</annotation>
+								<complexType>
+									<simpleContent>
+										<extension base="ebics:ReturnCodeType">
+											<attributeGroup ref="ebics:AuthenticationMarker"/>
+										</extension>
+									</simpleContent>
+								</complexType>
+							</element>
+							<element name="TimestampBankParameter" minOccurs="0">
+								<annotation>
+									<documentation xml:lang="de">Zeitstempel der letzten Aktualisierung der Bankparameter; nur in der Initialisierungsphase anzugeben.</documentation>
+								</annotation>
+								<complexType>
+									<simpleContent>
+										<extension base="ebics:TimestampType">
+											<attributeGroup ref="ebics:AuthenticationMarker"/>
+										</extension>
+									</simpleContent>
+								</complexType>
+							</element>
+						</sequence>
+					</complexType>
+				</element>
+			</sequence>
+			<attributeGroup ref="ebics:VersionAttrGroup"/>
+		</complexType>
+	</element>
+	<complexType name="KeyMgmntResponseMutableHeaderType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den variablen EBICS-Header.</documentation>
+		</annotation>
+		<sequence>
+			<element name="OrderID" type="ebics:OrderIDType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Auftragsnummer von Sendeaufträgen gemäß DFÜ-Abkommen (used for all key management order types except download order type HPB).</documentation>
+				</annotation>
+			</element>
+			<element name="ReturnCode" type="ebics:ReturnCodeType">
+				<annotation>
+					<documentation xml:lang="de">Rückmeldung des Ausführungsstatus mit einer eindeutigen Fehlernummer.</documentation>
+				</annotation>
+			</element>
+			<element name="ReportText" type="ebics:ReportTextType">
+				<annotation>
+					<documentation xml:lang="de">Klartext der Rückmeldung des Ausführungsstatus.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+</schema>
diff --git a/spec/xsd/ebics_orders_H005.xsd b/spec/xsd/ebics_orders_H005.xsd
new file mode 100644
index 00000000..30db1213
--- /dev/null
+++ b/spec/xsd/ebics_orders_H005.xsd
@@ -0,0 +1,2094 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- edited with XMLSpy v2017 sp2 (http://www.altova.com) by EBICS Working Group (July 3rd 2017) - Compared to the status of March 27th 2017 only the element group standardOrderParams was reinserted (as used in schema version H004) and several annotations in English added -->
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:esig="http://www.ebics.org/S002" xmlns:ebics="urn:org:ebics:H005" targetNamespace="urn:org:ebics:H005" elementFormDefault="qualified" attributeFormDefault="unqualified" version="1.0">
+	<annotation>
+		<documentation xml:lang="en">ebics_orders_H005.xsd contains order-based reference elements and order-based type definitions for EBICS.</documentation>
+		<documentation xml:lang="de">ebics_orders_H005.xsd enthält auftragsbezogene Referenzelemente und auftragsbezogene Typdefinitionen für EBICS.</documentation>
+	</annotation>
+	<import namespace="http://www.ebics.org/S002" schemaLocation="ebics_signature_S002.xsd"/>
+	<include schemaLocation="ebics_types_H005.xsd"/>
+	<!--Element definitions for the new EBICS order types (Hxx) - Binary interpretation of the XML clear text structure in the context.-->
+	<element name="EBICSOrderData" abstract="true">
+		<annotation>
+			<documentation xml:lang="de">XML-Klartext-Auftragsdaten für neue EBICS-Auftragsarten.</documentation>
+			<documentation xml:lang="en">Order data in XML format for new EBICS order types.</documentation>
+		</annotation>
+	</element>
+	<element name="HAAResponseOrderData" type="ebics:HAAResponseOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HAA (Antwort: abrufbare Auftragsarten abholen).</documentation>
+			<documentation xml:lang="en">Order data for order type HAA (response: receive downloadable order types).</documentation>
+		</annotation>
+	</element>
+	<element name="HCARequestOrderData" type="ebics:HCARequestOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HCA (Anfrage: Änderung der Teilnehmerschlüssel für Authentifikation und Verschlüsselung).</documentation>
+			<documentation xml:lang="en">Order data for order type HCA (request: replace user's keys for authentication and encryption).</documentation>
+		</annotation>
+	</element>
+	<element name="HCSRequestOrderData" type="ebics:HCSRequestOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HCS (Anfrage: Schlüsselwechsel aller Schlüssel).</documentation>
+			<documentation xml:lang="en">Order data for order type HCS (request: replace all keys).</documentation>
+		</annotation>
+	</element>
+	<element name="HIARequestOrderData" type="ebics:HIARequestOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HIA (Anfrage: Initialisierung der Teilnehmerschlüssel für Authentifikation und Verschlüsselung).</documentation>
+			<documentation xml:lang="en">Order data for order type HIA (request: initialise user's keys for authentication and encryption).</documentation>
+		</annotation>
+	</element>
+	<element name="H3KRequestOrderData" type="ebics:H3KRequestOrderDataType">
+		<annotation>
+			<documentation xml:lang="en">Order data for order type H3K (request: initialise all three user's keys).</documentation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart H3K (Anfrage: Initialisierung aller drei Teilnehmerschlüssel).</documentation>
+		</annotation>
+	</element>
+	<element name="HKDResponseOrderData" type="ebics:HKDResponseOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HKD (Antwort: Kunden- und Teilnehmerdaten des Kunden abholen).</documentation>
+			<documentation xml:lang="en">Order data for order type HKD (response: receive customer-based information on the customer and the customer's users).</documentation>
+		</annotation>
+		<key name="HKDAccountKey">
+			<annotation>
+				<documentation xml:lang="de">Schlüssel zur Identifikation des Kontos.</documentation>
+				<documentation xml:lang="en">Key for the identification of the account.</documentation>
+			</annotation>
+			<selector xpath="./ebics:PartnerInfo/ebics:AccountInfo"/>
+			<field xpath="@ID"/>
+		</key>
+		<keyref name="HKDAccountRef" refer="ebics:HKDAccountKey">
+			<annotation>
+				<documentation xml:lang="de">Referenz auf die Konten-Identifikationsschlüssel.</documentation>
+				<documentation xml:lang="en">Reference to the account identification keys.</documentation>
+			</annotation>
+			<selector xpath="./ebics:UserInfo/ebics:Permission"/>
+			<field xpath="ebics:AccountID"/>
+		</keyref>
+	</element>
+	<element name="HPBResponseOrderData" type="ebics:HPBResponseOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HPB (Antwort: Transfer der Bankschlüssel).</documentation>
+			<documentation xml:lang="en">Order data for order type HPB (response: receive bank's public keys).</documentation>
+		</annotation>
+	</element>
+	<element name="HPDResponseOrderData" type="ebics:HPDResponseOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HPD (Antwort: Bankparameter abholen).</documentation>
+			<documentation xml:lang="en">Order data for order type HPD (response: receive bank parameters).</documentation>
+		</annotation>
+	</element>
+	<element name="HTDResponseOrderData" type="ebics:HTDReponseOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HTD (Antwort: Kunden- und Teilnehmerdaten des Teilnehmers abholen).</documentation>
+			<documentation xml:lang="en">Order data for order type HTD (response: receive user-based information on the user's customer and the user herself/himself).</documentation>
+		</annotation>
+		<key name="HTDAccountKey">
+			<annotation>
+				<documentation xml:lang="de">Schlüssel zur Identifikation des Kontos.</documentation>
+				<documentation xml:lang="en">Key for the identification of the account.</documentation>
+			</annotation>
+			<selector xpath="./ebics:PartnerInfo/ebics:AccountInfo"/>
+			<field xpath="@ID"/>
+		</key>
+		<keyref name="HTDAccountRef" refer="ebics:HTDAccountKey">
+			<annotation>
+				<documentation xml:lang="de">Referenz auf die Konten-Identifikationsschlüssel.</documentation>
+				<documentation xml:lang="en">Reference to the account identification keys.</documentation>
+			</annotation>
+			<selector xpath="./ebics:UserInfo/ebics:Permission"/>
+			<field xpath="ebics:AccountID"/>
+		</keyref>
+	</element>
+	<element name="HVDResponseOrderData" type="ebics:HVDResponseOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HVD (Antwort: VEU-Status abrufen).</documentation>
+			<documentation xml:lang="en">Order data for order type HVD (response: receive the status of an order currently stored in the distributed signature processing unit).</documentation>
+		</annotation>
+	</element>
+	<element name="HVSRequestOrderData" type="ebics:HVSRequestOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HVS (Anfrage: VEU-Storno).</documentation>
+			<documentation xml:lang="en">Order data for order type HVS (request: reject an order currently stored in the distributed signature processing unit).</documentation>
+		</annotation>
+	</element>
+	<element name="HVTResponseOrderData" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HVT (Antwort: VEU-Transaktionsdetails abrufen).</documentation>
+			<documentation xml:lang="en">Order data for order type HVT (response: receive transaction details of an order currently stored in the distributed signature processing unit).</documentation>
+		</annotation>
+		<complexType>
+			<complexContent>
+				<extension base="ebics:HVTResponseOrderDataType"/>
+			</complexContent>
+		</complexType>
+	</element>
+	<element name="HVUResponseOrderData" type="ebics:HVUResponseOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HVU (Antwort: VEU-Übersicht abholen).</documentation>
+			<documentation xml:lang="en">Order data for order type HVU (response: receive summary of orders currently stored in the distributed signature processing unit).</documentation>
+		</annotation>
+	</element>
+	<element name="HVZResponseOrderData" type="ebics:HVZResponseOrderDataType" substitutionGroup="ebics:EBICSOrderData">
+		<annotation>
+			<documentation xml:lang="de">Auftragsdaten für Auftragsart HVZ (Antwort: VEU-Übersicht mit Zusatzinformationen abholen).</documentation>
+			<documentation xml:lang="en">Order data for order type HVZ (response: receive summary of orders currently stored in the distributed signature processing unit with additional information).</documentation>
+		</annotation>
+	</element>
+	<!--Element definitions for the ES. Binary interpreation of the XML clear text structure within the signature context.-->
+	<element name="EBICSSignatureData" abstract="true">
+		<annotation>
+			<documentation xml:lang="de">XML-Strukturen für bankfachliche Elektronische Unterschriften (EUs).</documentation>
+			<documentation xml:lang="en">contains the digital signatures.</documentation>
+		</annotation>
+	</element>
+	<element name="BankSignatureData" type="ebics:BankSignatureDataSigBookType" substitutionGroup="ebics:EBICSSignatureData">
+		<annotation>
+			<documentation xml:lang="de">enthält die EU des Kreditinstituts.</documentation>
+			<documentation xml:lang="en">contains the digital signatures.</documentation>
+		</annotation>
+	</element>
+	<!--Element definitions for additional order parameters. XML clear text is embedded in the header data.-->
+	<element name="OrderParams" abstract="true">
+		<annotation>
+			<documentation xml:lang="de">zusätzliche Auftragsparameter, die zur Ausführung des Auftrags notwendig sind.</documentation>
+			<documentation xml:lang="en">additional order parameters required to execute the order.</documentation>
+		</annotation>
+	</element>
+	<element name="HVDOrderParams" type="ebics:HVDOrderParamsType" substitutionGroup="ebics:OrderParams">
+		<annotation>
+			<documentation xml:lang="de">zusätzliche Auftragsparameter für Auftragsart HVD.</documentation>
+			<documentation xml:lang="en">additional order parameters for order type HVD.</documentation>
+		</annotation>
+	</element>
+	<element name="HVEOrderParams" type="ebics:HVEOrderParamsType" substitutionGroup="ebics:OrderParams">
+		<annotation>
+			<documentation xml:lang="de">zusätzliche Auftragsparameter für Auftragsart HVE.</documentation>
+			<documentation xml:lang="en">additional order parameters for order type HVE.</documentation>
+		</annotation>
+	</element>
+	<element name="HVSOrderParams" type="ebics:HVSOrderParamsType" substitutionGroup="ebics:OrderParams">
+		<annotation>
+			<documentation xml:lang="de">zusätzliche Auftragsparameter für Auftragsart HVS.</documentation>
+			<documentation xml:lang="en">additional order parameters for order type HVS.</documentation>
+		</annotation>
+	</element>
+	<element name="HVTOrderParams" type="ebics:HVTOrderParamsType" substitutionGroup="ebics:OrderParams">
+		<annotation>
+			<documentation xml:lang="de">zusätzliche Auftragsparameter für Auftragsart HVT.</documentation>
+			<documentation xml:lang="en">additional order parameters for order type HVT.</documentation>
+		</annotation>
+	</element>
+	<element name="HVUOrderParams" type="ebics:HVUOrderParamsType" substitutionGroup="ebics:OrderParams">
+		<annotation>
+			<documentation xml:lang="de">zusätzliche Auftragsparameter für Auftragsart HVU.</documentation>
+			<documentation xml:lang="en">additional order parameters for order type HVU.</documentation>
+		</annotation>
+	</element>
+	<element name="HVZOrderParams" type="ebics:HVZOrderParamsType" substitutionGroup="ebics:OrderParams">
+		<annotation>
+			<documentation xml:lang="de">zusätzliche Auftragsparameter für Auftragsart HVZ.</documentation>
+			<documentation xml:lang="en">additional order parameters for order type HVZ.</documentation>
+		</annotation>
+	</element>
+	<element name="StandardOrderParams" type="ebics:StandardOrderParamsType" substitutionGroup="ebics:OrderParams">
+		<annotation>
+			<documentation xml:lang="de">zusätzliche Auftragsparameter für Standard-Auftragsarten.</documentation>
+			<documentation xml:lang="en">additional order parameters for standard order types.</documentation>
+		</annotation>
+	</element>
+	<!--Element groups and structural information.-->
+	<group name="HVRequestStructure">
+		<annotation>
+			<documentation xml:lang="de">Standard-Requeststruktur für HVx-Aufträge (HVD, HVT, HVE, HVS).</documentation>
+			<documentation xml:lang="en">Standard request structure for HVx orders (HVD, HVT, HVE, HVS).</documentation>
+		</annotation>
+		<sequence>
+			<annotation>
+				<documentation xml:lang="de">Standard-Requestdaten.</documentation>
+				<documentation xml:lang="en">Standard request data.</documentation>
+			</annotation>
+			<element name="PartnerID" type="ebics:PartnerIDType">
+				<annotation>
+					<documentation xml:lang="de">Kunden-ID des Einreichers des ausgewählten Auftrags.</documentation>
+					<documentation xml:lang="en">Customer ID of the presenter of the selected order.</documentation>
+				</annotation>
+			</element>
+			<element name="Service" type="ebics:RestrictedServiceType">
+				<annotation>
+					<documentation xml:lang="de">BTF Service Parameter struktur im Falle von BTU/BTD</documentation>
+					<documentation xml:lang="en">Identification of the file format in the case of FUL/FDL</documentation>
+				</annotation>
+			</element>
+			<element name="OrderID" type="ebics:OrderIDType">
+				<annotation>
+					<documentation xml:lang="de">Auftragsnummer des ausgewählten Auftrags.</documentation>
+					<documentation xml:lang="en">Order ID of the selected order.</documentation>
+				</annotation>
+			</element>
+		</sequence>
+	</group>
+	<attributeGroup name="AuthenticationMarker">
+		<annotation>
+			<documentation xml:lang="de">Marker für Elemente und deren Substrukturen, die authentifiziert werden sollen.</documentation>
+			<documentation xml:lang="en">Marker for elements and their substructures that are to be authenticated.</documentation>
+		</annotation>
+		<attribute name="authenticate" type="boolean" use="required" fixed="true">
+			<annotation>
+				<documentation xml:lang="de">Das zugehörige Element ist mitsamt seinen Unterstrukturen zu authentifizieren.</documentation>
+				<documentation xml:lang="en">The element (and its substructures) that belongs to this attribute is to be authenticated.</documentation>
+			</annotation>
+		</attribute>
+	</attributeGroup>
+	<attributeGroup name="OptSupportFlag">
+		<annotation>
+			<documentation xml:lang="de">optionales Support-Flag, Default = true.</documentation>
+			<documentation xml:lang="en">optional support flag, default = true.</documentation>
+		</annotation>
+		<attribute name="supported" type="boolean" use="optional" default="true">
+			<annotation>
+				<documentation xml:lang="de">Wird die Funktion unterstützt?</documentation>
+				<documentation xml:lang="en">Is this function supported?</documentation>
+			</annotation>
+		</attribute>
+		<anyAttribute namespace="##targetNamespace" processContents="strict"/>
+	</attributeGroup>
+	<attributeGroup name="SignerPermission">
+		<annotation>
+			<documentation xml:lang="de">EU-Berechtigungsinformationen.</documentation>
+			<documentation xml:lang="en">permission information of a user's digital signature.</documentation>
+		</annotation>
+		<attribute name="AuthorisationLevel" type="ebics:AuthorisationLevelType" use="required">
+			<annotation>
+				<documentation xml:lang="de">Unterschriftsberechtigung des Teilnehmers, der unterzeichnet hat.</documentation>
+				<documentation xml:lang="en">Authorisation level of the user that signed the order.</documentation>
+			</annotation>
+		</attribute>
+		<anyAttribute namespace="##targetNamespace" processContents="strict"/>
+	</attributeGroup>
+	<!--Type definitions and order-related complex types.-->
+	<complexType name="BankSignatureDataSigBookType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Signaturdaten des Kreditinstituts beim EU-Transfer.</documentation>
+			<documentation xml:lang="en">Data type for digital signature data transferred using EBICS.</documentation>
+		</annotation>
+		<sequence>
+			<element name="OrderSignature" minOccurs="0" maxOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">bankfachliche Elektronische Unterschrift.</documentation>
+					<documentation xml:lang="en">Digital signature (either autorising an order or applied for transportation).</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="ebics:SignatureType"/>
+					</simpleContent>
+				</complexType>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="PreValidationRequestType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Vorabprüfung (Anfrage).</documentation>
+			<documentation xml:lang="en">Data type for pre-validation (request).</documentation>
+		</annotation>
+		<sequence>
+			<annotation>
+				<documentation xml:lang="de">Client sendet den Hashwert der Auftragsdaten und alle weiteren Daten, die er im Rahmen der Vorabprüfung zur Verfügung stellen will</documentation>
+			</annotation>
+			<element name="DataDigest" type="ebics:DataDigestType" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Hashwert der zu übertragenden Auftragsdatendatei für die Vorabprüfung.</documentation>
+					<documentation xml:lang="en">Hashvalue of the transmitted order data for the prevalidation.</documentation>
+				</annotation>
+			</element>
+			<element name="AccountAuthorisation" type="ebics:PreValidationAccountAuthType" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Kontoangabe zur Kontoberechtigung für diesen Zahlungsverkehrsauftrag bei der Vorabprüfung.</documentation>
+					<documentation xml:lang="en">Account information for authorisation checks for the payment order within the prevalidation.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="PreValidationAccountAuthType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Kontenberechtigungsdaten zur Vorabprüfung.</documentation>
+			<documentation xml:lang="en">Data type for the account authorisation data for the prevalidation.</documentation>
+		</annotation>
+		<complexContent>
+			<extension base="ebics:AccountType">
+				<sequence>
+					<element name="Amount" type="ebics:AmountType" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">Summe der Zahlungsverkehrsaufträge dieses Kontos für die Höchstbetragsprüfung der EU.</documentation>
+							<documentation xml:lang="en">Total sum of the ordered payments regarding this account in order to check the maximum amount limit of the signature permission grades.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</extension>
+		</complexContent>
+	</complexType>
+	<complexType name="DataTransferRequestType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den Transfer von Auftragsdaten (Anfrage).</documentation>
+			<documentation xml:lang="en">Data type for the transfer of order data (request).</documentation>
+		</annotation>
+		<sequence>
+			<choice>
+				<annotation>
+					<documentation xml:lang="de">Transaktionsphase?</documentation>
+				</annotation>
+				<sequence>
+					<annotation>
+						<documentation xml:lang="de">Initialisierungsphase: Transfer der Signaturdaten (EUs) und des Transaktionsschlüssels.</documentation>
+						<documentation xml:lang="en">Inituialisation phase: Transfer of signatur data (ESs) and transaktion key.</documentation>
+					</annotation>
+					<element name="DataEncryptionInfo">
+						<annotation>
+							<documentation xml:lang="de">Information zur Verschlüsselung der Signatur- und Auftragsdaten.</documentation>
+							<documentation xml:lang="en">Information regarding the encryption of signature and order data.</documentation>
+						</annotation>
+						<complexType>
+							<complexContent>
+								<extension base="ebics:DataEncryptionInfoType">
+									<attributeGroup ref="ebics:AuthenticationMarker"/>
+								</extension>
+							</complexContent>
+						</complexType>
+					</element>
+					<element name="SignatureData">
+						<annotation>
+							<documentation xml:lang="de">enthält Signaturdaten (EUs).</documentation>
+							<documentation xml:lang="en">contains signature data (ESs).</documentation>
+						</annotation>
+						<complexType>
+							<simpleContent>
+								<extension base="ebics:SignatureDataType">
+									<attributeGroup ref="ebics:AuthenticationMarker"/>
+								</extension>
+							</simpleContent>
+						</complexType>
+					</element>
+					<element name="DataDigest" type="ebics:DataDigestType">
+						<annotation>
+							<documentation xml:lang="de">Hashwert der Auftragsdaten.</documentation>
+							<documentation xml:lang="de">Hashvalue of the order data.</documentation>
+						</annotation>
+					</element>
+					<element name="AdditionalOrderInfo" type="ebics:String255Type" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">Additional Information about the order (unstructured, up to 255 characters).</documentation>
+						</annotation>
+					</element>
+				</sequence>
+				<sequence>
+					<annotation>
+						<documentation xml:lang="de">Transferphase: Transfer von Auftragsdaten.</documentation>
+						<documentation xml:lang="en">Transferphase: Transfer of order data.</documentation>
+					</annotation>
+					<element name="OrderData">
+						<annotation>
+							<documentation xml:lang="de">enthält Auftragsdaten.</documentation>
+							<documentation xml:lang="en">contains order data.</documentation>
+						</annotation>
+						<complexType>
+							<simpleContent>
+								<extension base="ebics:OrderDataType">
+									<anyAttribute namespace="##targetNamespace" processContents="lax"/>
+								</extension>
+							</simpleContent>
+						</complexType>
+					</element>
+				</sequence>
+			</choice>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="DataTransferResponseType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den Transfer von Auftragsdaten (Antwort).</documentation>
+		</annotation>
+		<sequence>
+			<sequence minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Transfer des Sitzungsschlüssels und (optional) der Signaturdaten (EUs); nur in der Initialisierungsphase anzugeben.</documentation>
+					<documentation xml:lang="en">Transfer of the session key and (optional) signature data (ESs); to be specified only in the initialisation phase.</documentation>
+				</annotation>
+				<element name="DataEncryptionInfo">
+					<annotation>
+						<documentation xml:lang="de">Information zur Verschlüsselung der Signatur- und Auftragsdaten.</documentation>
+						<documentation xml:lang="en">Information regarding the encryption of signature and order data.</documentation>
+					</annotation>
+					<complexType>
+						<complexContent>
+							<extension base="ebics:DataEncryptionInfoType">
+								<attributeGroup ref="ebics:AuthenticationMarker"/>
+							</extension>
+						</complexContent>
+					</complexType>
+				</element>
+				<element name="SignatureData" minOccurs="0" maxOccurs="0">
+					<annotation>
+						<documentation xml:lang="de">enthält Signaturdaten (EUs).</documentation>
+						<documentation xml:lang="en">contains signature data (ESs).</documentation>
+					</annotation>
+					<complexType>
+						<simpleContent>
+							<extension base="ebics:SignatureDataType">
+								<attributeGroup ref="ebics:AuthenticationMarker"/>
+							</extension>
+						</simpleContent>
+					</complexType>
+				</element>
+			</sequence>
+			<element name="OrderData">
+				<annotation>
+					<documentation xml:lang="de">enthält Auftragsdaten.</documentation>
+					<documentation xml:lang="en">contains order data.</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="ebics:OrderDataType">
+							<anyAttribute namespace="##targetNamespace" processContents="lax"/>
+						</extension>
+					</simpleContent>
+				</complexType>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="TransferReceiptRequestType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den Transfer von Transferquittungen.</documentation>
+			<documentation xml:lang="en">Data type for the transfer of transfer receipts.</documentation>
+		</annotation>
+		<sequence>
+			<element name="ReceiptCode" type="ebics:ReceiptCodeType">
+				<annotation>
+					<documentation xml:lang="de">Quittierungscode für Auftragsdatentransfer.</documentation>
+					<documentation xml:lang="en">Receipt code fpr transfer of order data.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="TransferReceiptResponseType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den Transfer von Antwortcodes.</documentation>
+		</annotation>
+		<sequence>
+			<element name="ReturnCodeReceipt" type="ebics:ReturnCodeType">
+				<annotation>
+					<documentation xml:lang="de">Antwortcode für den vorangegangenen Transfer.</documentation>
+					<documentation xml:lang="en">response code for the foregoing transfer.</documentation>
+				</annotation>
+			</element>
+			<element name="TimestampBankParameter" type="ebics:TimestampType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Zeitstempel der letzten Aktualisierung der Bankparameter.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HAAResponseOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HAA (Antwort: abrufbare Auftragsarten abholen).</documentation>
+			<documentation xml:lang="en">Data type for order data of order type HAA (Response: Download of available order data).</documentation>
+		</annotation>
+		<sequence>
+			<element name="Service" type="ebics:RestrictedServiceType" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Liste von Auftragsarten, für die Daten bereit stehen.</documentation>
+					<documentation xml:lang="en">List of order types for which data are available.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HCARequestOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HCA (Anfrage: Änderung der Teilnehmerschlüssel für Authentifikation und Verschlüsselung).</documentation>
+			<documentation xml:lang="en">Data type for order data regarding order type HCA (Request: Update of Subscriber's key for authentication and encryption).</documentation>
+		</annotation>
+		<sequence>
+			<element name="AuthenticationPubKeyInfo" type="ebics:AuthenticationPubKeyInfoType">
+				<annotation>
+					<documentation xml:lang="de">öffentlicher Authentifikationsschlüssel.</documentation>
+					<documentation xml:lang="en">public key for authentication.</documentation>
+				</annotation>
+			</element>
+			<element name="EncryptionPubKeyInfo" type="ebics:EncryptionPubKeyInfoType">
+				<annotation>
+					<documentation xml:lang="de">öffentlicher Verschlüsselungsschlüssel.</documentation>
+					<documentation xml:lang="en">public key for encryption.</documentation>
+				</annotation>
+			</element>
+			<element name="PartnerID" type="ebics:PartnerIDType">
+				<annotation>
+					<documentation xml:lang="de">Kunden-ID.</documentation>
+					<documentation xml:lang="en">Partner-ID.</documentation>
+				</annotation>
+			</element>
+			<element name="UserID" type="ebics:UserIDType">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmer-ID.</documentation>
+					<documentation xml:lang="en">User-ID.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HCSRequestOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HCS (Anfrage: Schlüsselwechsel aller Schlüssel).</documentation>
+			<documentation xml:lang="en">Data type for order data for order type HCS (Request: Update of all keys).</documentation>
+		</annotation>
+		<sequence>
+			<element name="AuthenticationPubKeyInfo" type="ebics:AuthenticationPubKeyInfoType">
+				<annotation>
+					<documentation xml:lang="de">öffentlicher Authentifikationsschlüssel.</documentation>
+					<documentation xml:lang="en">public key for authentication.</documentation>
+				</annotation>
+			</element>
+			<element name="EncryptionPubKeyInfo" type="ebics:EncryptionPubKeyInfoType">
+				<annotation>
+					<documentation xml:lang="de">öffentlicher Verschlüsselungsschlüssel.</documentation>
+					<documentation xml:lang="en">public key for encryption.</documentation>
+				</annotation>
+			</element>
+			<element ref="esig:SignaturePubKeyInfo"/>
+			<element name="PartnerID" type="ebics:PartnerIDType">
+				<annotation>
+					<documentation xml:lang="de">Kunden-ID.</documentation>
+					<documentation xml:lang="en">Partner-ID.</documentation>
+				</annotation>
+			</element>
+			<element name="UserID" type="ebics:UserIDType">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmer-ID.</documentation>
+					<documentation xml:lang="en">User-ID.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HIARequestOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HIA (Anfrage: Initialisierung der Teilnehmerschlüssel für Authentifikation und Verschlüsselung).</documentation>
+			<documentation xml:lang="en">Data type for order data for order type HIA (Request: Initialisation of subcriber keys for authentication and encryption).</documentation>
+		</annotation>
+		<sequence>
+			<element name="AuthenticationPubKeyInfo" type="ebics:AuthenticationPubKeyInfoType">
+				<annotation>
+					<documentation xml:lang="de">öffentlicher Authentifikationsschlüssel.</documentation>
+					<documentation xml:lang="en">public key for authentication.</documentation>
+				</annotation>
+			</element>
+			<element name="EncryptionPubKeyInfo" type="ebics:EncryptionPubKeyInfoType">
+				<annotation>
+					<documentation xml:lang="de">öffentlicher Verschlüsselungsschlüssel.</documentation>
+					<documentation xml:lang="en">public key for encryption.</documentation>
+				</annotation>
+			</element>
+			<element name="PartnerID" type="ebics:PartnerIDType">
+				<annotation>
+					<documentation xml:lang="de">Kunden-ID.</documentation>
+					<documentation xml:lang="en">Partner-ID.</documentation>
+				</annotation>
+			</element>
+			<element name="UserID" type="ebics:UserIDType">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmer-ID.</documentation>
+					<documentation xml:lang="en">User-ID.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="H3KRequestOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart H3K (Anfrage: Initialisierung aller drei Teilnehmerschlüssel).</documentation>
+			<documentation xml:lang="en">Order type for order data H3K (request: initialise all three user's keys).</documentation>
+		</annotation>
+		<sequence>
+			<element name="SignatureCertificateInfo" type="ebics:SignatureCertificateInfoType">
+				<annotation>
+					<documentation xml:lang="en">Key for electronic Signature</documentation>
+					<documentation xml:lang="de">Signaturschlüssel.</documentation>
+				</annotation>
+			</element>
+			<element name="AuthenticationCertificateInfo" type="ebics:AuthenticationCertificateInfoType">
+				<annotation>
+					<documentation xml:lang="en">Authentication key</documentation>
+					<documentation xml:lang="de">Authentifikationsschlüssel.</documentation>
+				</annotation>
+			</element>
+			<element name="EncryptionCertificateInfo" type="ebics:EncryptionCertificateInfoType">
+				<annotation>
+					<documentation xml:lang="en">Encryption key</documentation>
+					<documentation xml:lang="de">Verschlüsselungsschlüssel.</documentation>
+				</annotation>
+			</element>
+			<element name="PartnerID" type="ebics:PartnerIDType">
+				<annotation>
+					<documentation xml:lang="en">PartnerID.</documentation>
+					<documentation xml:lang="de">Kunden-ID.</documentation>
+				</annotation>
+			</element>
+			<element name="UserID" type="ebics:UserIDType">
+				<annotation>
+					<documentation xml:lang="en">UserID.</documentation>
+					<documentation xml:lang="de">Teilnehmer-ID.</documentation>
+				</annotation>
+			</element>
+		</sequence>
+	</complexType>
+	<complexType name="HKDResponseOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HKD (Antwort: Kunden- und Teilnehmerdaten des Kunden abholen).</documentation>
+			<documentation xml:lang="en">Order data for order type HKD (response: receive customer based information on the customer and the customer's user.</documentation>
+		</annotation>
+		<sequence>
+			<element name="PartnerInfo" type="ebics:PartnerInfoType">
+				<annotation>
+					<documentation xml:lang="de">Kundendaten.</documentation>
+					<documentation xml:lang="en">Customer data.</documentation>
+				</annotation>
+			</element>
+			<element name="UserInfo" type="ebics:UserInfoType" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmerdaten.</documentation>
+					<documentation xml:lang="en">User data.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HPBResponseOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HPB (Antwort: Transfer der Bankschlüssel).</documentation>
+			<documentation xml:lang="en">Data type for order data for order type HPB (Response: Transfer of bank keys).</documentation>
+		</annotation>
+		<sequence>
+			<element name="AuthenticationPubKeyInfo" type="ebics:AuthenticationPubKeyInfoType">
+				<annotation>
+					<documentation xml:lang="de">öffentlicher Authentifikationsschlüssel.</documentation>
+					<documentation xml:lang="en">public authentication key</documentation>
+				</annotation>
+			</element>
+			<element name="EncryptionPubKeyInfo" type="ebics:EncryptionPubKeyInfoType">
+				<annotation>
+					<documentation xml:lang="de">öffentlicher Verschlüsselungsschlüssel.</documentation>
+					<documentation xml:lang="en">public encryption key</documentation>
+				</annotation>
+			</element>
+			<element ref="esig:SignaturePubKeyInfo" minOccurs="0" maxOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">öffentlicher EU-Signaturschlüssel.</documentation>
+					<documentation xml:lang="en">public ES key.</documentation>
+				</annotation>
+			</element>
+			<element name="HostID" type="ebics:HostIDType">
+				<annotation>
+					<documentation xml:lang="de">Banksystem-ID.</documentation>
+					<documentation xml:lang="en">Host-ID.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HPDResponseOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HPD (Antwort: Bankparameter abholen).</documentation>
+			<documentation xml:lang="en">Data type for order data for order type HPD (Response: Download bank parameters).</documentation>
+		</annotation>
+		<sequence>
+			<element name="AccessParams" type="ebics:HPDAccessParamsType">
+				<annotation>
+					<documentation xml:lang="de">Zugangsparameter.</documentation>
+					<documentation xml:lang="en">Access Parameter.</documentation>
+				</annotation>
+			</element>
+			<element name="ProtocolParams" type="ebics:HPDProtocolParamsType">
+				<annotation>
+					<documentation xml:lang="de">Protokollparameter.</documentation>
+					<documentation xml:lang="en">Protocol Parameter.</documentation>
+				</annotation>
+			</element>
+		</sequence>
+	</complexType>
+	<complexType name="HPDAccessParamsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für HPD-Zugangsparameter.</documentation>
+			<documentation xml:lang="en">data type for HPD Access Parameter.</documentation>
+		</annotation>
+		<sequence>
+			<element name="URL" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">institutsspezifische IP-Adresse/URL.</documentation>
+					<documentation xml:lang="en">individual IP-address/URL of the bank.</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="anyURI">
+							<attribute name="valid_from" type="ebics:TimestampType">
+								<annotation>
+									<documentation xml:lang="de">Gültigkeitsbeginn für die angegebene URL/IP.</documentation>
+									<documentation xml:lang="en">Valid-From-Date of the URL/IP.</documentation>
+								</annotation>
+							</attribute>
+						</extension>
+					</simpleContent>
+				</complexType>
+			</element>
+			<element name="Institute">
+				<annotation>
+					<documentation xml:lang="de">Institutsbezeichnung.</documentation>
+					<documentation xml:lang="en">Name of the bank.</documentation>
+				</annotation>
+				<simpleType>
+					<restriction base="normalizedString">
+						<maxLength value="80"/>
+					</restriction>
+				</simpleType>
+			</element>
+			<element name="HostID" type="ebics:HostIDType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Banksystem-ID.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HPDProtocolParamsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für HPD-Protokollparameter.</documentation>
+			<documentation xml:lang="en">Data type for HPD's parameters regarding the EBICS protocol.</documentation>
+		</annotation>
+		<sequence>
+			<element name="Version" type="ebics:HPDVersionType">
+				<annotation>
+					<documentation xml:lang="de">Spezifikation unterstützter Versionen.</documentation>
+					<documentation xml:lang="en">Specification of supported versions..</documentation>
+				</annotation>
+			</element>
+			<element name="Recovery" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Parameter zur Recovery-Funktion (Wiederaufnahme abgebrochener Übertragungen).</documentation>
+					<documentation xml:lang="en">Parameter denoting the recovery function (recovery of aborted transmissions).</documentation>
+				</annotation>
+				<complexType>
+					<attributeGroup ref="ebics:OptSupportFlag"/>
+				</complexType>
+			</element>
+			<element name="PreValidation" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Parameter zur Vorabprüfung (über die Übermittlung der EU hinaus).</documentation>
+					<documentation xml:lang="en">Parameter denoting the pre-validation (beyond transmission of signatures).</documentation>
+				</annotation>
+				<complexType>
+					<annotation>
+						<documentation xml:lang="de">Optionales Support-Flag, Default = true.</documentation>
+						<documentation xml:lang="en">Optional support flag, default = true.</documentation>
+					</annotation>
+					<attributeGroup ref="ebics:OptSupportFlag"/>
+				</complexType>
+			</element>
+			<element name="ClientDataDownload" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Parameter zum Download von Kunden- und Teilnehmerdaten (Auftragsarten HKD/HTD).</documentation>
+					<documentation xml:lang="en">Parameter denoting the download of customer and user data (order types HKD/HTD).</documentation>
+				</annotation>
+				<complexType>
+					<attributeGroup ref="ebics:OptSupportFlag"/>
+				</complexType>
+			</element>
+			<element name="DownloadableOrderData" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Parameter zum Abruf von Auftragsarten, zu denen Auftragsdaten verfügbar sind (Auftragsart HAA).</documentation>
+					<documentation xml:lang="en">Parameter denoting the reception of order types which provides downloadable order data (order type HAA).</documentation>
+				</annotation>
+				<complexType>
+					<attributeGroup ref="ebics:OptSupportFlag"/>
+				</complexType>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HPDVersionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für HPD-Versionsinformationen.</documentation>
+			<documentation xml:lang="en">Data type for HPD version information.</documentation>
+		</annotation>
+		<sequence>
+			<element name="Protocol">
+				<annotation>
+					<documentation xml:lang="de">unterstützte EBICS-Protokollversionen (H...).</documentation>
+					<documentation xml:lang="en">supported EBICS protocol versions. (H...).</documentation>
+				</annotation>
+				<simpleType>
+					<list itemType="ebics:ProtocolVersionType"/>
+				</simpleType>
+			</element>
+			<element name="Authentication">
+				<annotation>
+					<documentation xml:lang="de">unterstützte Versionen der Authentifikation (X...).</documentation>
+					<documentation xml:lang="en">supported version for authentication (X...).</documentation>
+				</annotation>
+				<simpleType>
+					<list itemType="ebics:AuthenticationVersionType"/>
+				</simpleType>
+			</element>
+			<element name="Encryption">
+				<annotation>
+					<documentation xml:lang="de">unterstützte Versionen der Verschlüsselung (E...).</documentation>
+					<documentation xml:lang="en">supported version for encryption (E...).</documentation>
+				</annotation>
+				<simpleType>
+					<list itemType="ebics:EncryptionVersionType"/>
+				</simpleType>
+			</element>
+			<element name="Signature">
+				<annotation>
+					<documentation xml:lang="de">unterstützte EU-Versionen (A...).</documentation>
+					<documentation xml:lang="en">supported version for ES (A...).</documentation>
+				</annotation>
+				<simpleType>
+					<list itemType="esig:SignatureVersionType"/>
+				</simpleType>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HTDReponseOrderDataType">
+		<annotation>
+			<documentation>Datentyp für Auftragsdaten für Auftragsart HTD (Antwort: Kunden- und Teilnehmerdaten des Teilnehmers abholen).</documentation>
+			<documentation xml:lang="en">Data type for order data for order type HTD (Response: Download partner- and user data).</documentation>
+		</annotation>
+		<sequence>
+			<element name="PartnerInfo" type="ebics:PartnerInfoType">
+				<annotation>
+					<documentation xml:lang="de">Kundendaten.</documentation>
+					<documentation xml:lang="en">Customer data.</documentation>
+				</annotation>
+			</element>
+			<element name="UserInfo" type="ebics:UserInfoType">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmerdaten.</documentation>
+					<documentation xml:lang="en">User data.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVDResponseOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HVD (Antwort: VEU-Status abrufen).</documentation>
+			<documentation xml:lang="en">Data type for order data for order type HVD (Response: EDS-status).</documentation>
+		</annotation>
+		<sequence>
+			<element name="DataDigest" type="ebics:DataDigestType">
+				<annotation>
+					<documentation xml:lang="de">Hashwert der Auftragsdaten.</documentation>
+					<documentation xml:lang="en">Hash value of the order data.</documentation>
+				</annotation>
+			</element>
+			<element name="DisplayFile" type="base64Binary">
+				<annotation>
+					<documentation xml:lang="de">Begleitzettel/"Displaydatei" (entspricht der Dateianzeige im Kundenprotokoll gemäß DFÜ-Abkommen).</documentation>
+					<documentation xml:lang="en">Accompanying ticket/"display file" (corresponds to the display file of the customer's journal according to the document "DFÜ-Abkommen").</documentation>
+				</annotation>
+			</element>
+			<element name="OrderDataAvailable" type="boolean">
+				<annotation>
+					<documentation xml:lang="de">Kann die Auftragsdatei im Originalformat abgeholt werden? (HVT mit completeOrderData=true)</documentation>
+					<documentation xml:lang="en">Can the order file be downloaded in the original format? (HVT with completeOrderData=true)</documentation>
+				</annotation>
+			</element>
+			<element name="OrderDataSize" type="positiveInteger">
+				<annotation>
+					<documentation xml:lang="de">Größe der unkomprimierten Auftragsdaten in Bytes.</documentation>
+					<documentation xml:lang="en">Size of the uncompressed order data (byte count).</documentation>
+				</annotation>
+			</element>
+			<element name="OrderDetailsAvailable" type="boolean">
+				<annotation>
+					<documentation xml:lang="de">Können die Auftragsdetails als XML-Dokument HVTResponseOrderData abgeholt werden?  (HVT mit completeOrderData=false)</documentation>
+					<documentation xml:lang="en">Can the order details be downloaded as XML document HVTResponseOrderData?  (HVT with completeOrderData=false)</documentation>
+				</annotation>
+			</element>
+			<element name="BankSignature" type="ebics:SignatureType" minOccurs="0" maxOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">bankfachliche Elektronische Unterschrift des Kreditinstituts über Hashwert und Displaydatei.</documentation>
+					<documentation xml:lang="en">Digital Signature issued by the bank, covering the hash value and the accompanying ticket.</documentation>
+				</annotation>
+			</element>
+			<element name="SignerInfo" type="ebics:SignerInfoType" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Informationen zu den bisherigen Unterzeichnern.</documentation>
+					<documentation xml:lang="en">Information about the already existing signers.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVDOrderParamsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für zusätzliche Auftragsparameter für Auftragsart HVD.</documentation>
+			<documentation xml:lang="en">Data type for additional order parameters for order type HVD.</documentation>
+		</annotation>
+		<sequence>
+			<group ref="ebics:HVRequestStructure"/>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVEOrderParamsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für zusätzliche Auftragsparameter für Auftragsart HVE.</documentation>
+			<documentation xml:lang="en">Data type for additional order parameters for order type HVE.</documentation>
+		</annotation>
+		<sequence>
+			<group ref="ebics:HVRequestStructure"/>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVSOrderParamsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für zusätzliche Auftragsparameter für Auftragsart HVS.</documentation>
+			<documentation xml:lang="en">Data type for additional order parameters for order type HVS.</documentation>
+		</annotation>
+		<sequence>
+			<group ref="ebics:HVRequestStructure"/>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVSRequestOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HVS (Anfrage: VEU-Storno).</documentation>
+			<documentation xml:lang="en">Data type for order data for order type HVS (request: EDS cancellation).</documentation>
+		</annotation>
+		<sequence>
+			<element name="CancelledDataDigest" type="ebics:DataDigestType">
+				<annotation>
+					<documentation xml:lang="de">Hashwert der Auftragsdaten des stornierten Auftrags.</documentation>
+					<documentation xml:lang="en">Hash value of order data of cancelled order.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVTResponseOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Antwort mit Einzelauftraginfos für Auftragsart HVT (Antwort VEU-Transaktionsdetails abrufen mit completeOrderData="false").</documentation>
+			<documentation xml:lang="en">Data type for a response containing information about single transactions for order type HVT (response: EDS transaction details with completeOrderData="false").</documentation>
+		</annotation>
+		<sequence>
+			<element name="NumOrderInfos" type="ebics:NumOrderInfosType">
+				<annotation>
+					<documentation xml:lang="de">Gesamtanzahl der Einzelaufträge für den Auftrag.</documentation>
+					<documentation xml:lang="en">Total number of order infos for the order.</documentation>
+				</annotation>
+			</element>
+			<element name="OrderInfo" type="ebics:HVTOrderInfoType" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Einzelauftragsinfos.</documentation>
+					<documentation xml:lang="en">Particular order content information requested for display matters.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVTAccountInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für HVT-Konteninformationen.</documentation>
+			<documentation xml:lang="en">Data type for account information regarding order type HVT.</documentation>
+		</annotation>
+		<complexContent>
+			<extension base="ebics:AttributedAccountType"/>
+		</complexContent>
+	</complexType>
+	<complexType name="HVTOrderInfoType">
+		<annotation>
+			<documentation xml:lang="de">//MODIFIED - Replaced Element OrderFormat with MsgName// Datentyp für HVT-Auftragsinformationen.</documentation>
+		</annotation>
+		<sequence>
+			<element name="MsgName" type="ebics:MessageType" minOccurs="0"/>
+			<element name="AccountInfo" type="ebics:HVTAccountInfoType" minOccurs="2" maxOccurs="3">
+				<annotation>
+					<documentation xml:lang="de">kontobezogene Details des Auftrags (Auftraggeber, Empfänger etc.).</documentation>
+					<documentation xml:lang="en">account related details of the order (ordering party, receiver etc.).</documentation>
+				</annotation>
+			</element>
+			<element name="ExecutionDate" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Ausführungsdatum.</documentation>
+					<documentation xml:lang="en">Execution date.</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="date"/>
+					</simpleContent>
+				</complexType>
+			</element>
+			<element name="Amount">
+				<annotation>
+					<documentation xml:lang="de">Betrag.</documentation>
+					<documentation xml:lang="en">Amount.</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="ebics:AmountValueType">
+							<attribute name="isCredit" type="boolean" use="optional">
+								<annotation>
+									<documentation xml:lang="de">Gutschrift (isCredit = "true") oder Lastschrift (isCredit = "false")?</documentation>
+									<documentation xml:lang="en">Credit (isCredit = "true") or debit (isCredit = "false")?</documentation>
+								</annotation>
+							</attribute>
+							<attribute name="Currency" type="ebics:CurrencyBaseType" use="optional">
+								<annotation>
+									<documentation xml:lang="de">Währungscode.</documentation>
+									<documentation xml:lang="en">Currency code.</documentation>
+								</annotation>
+							</attribute>
+						</extension>
+					</simpleContent>
+				</complexType>
+			</element>
+			<element name="Description" minOccurs="0" maxOccurs="4">
+				<annotation>
+					<documentation xml:lang="de">Textfeld zur weiteren Beschreibung der Transaktion (Verwendungszweck, Auftragsdetails, Kommentar).</documentation>
+					<documentation xml:lang="en">text field for additional descriptions regarding the transaction (remittance information, order details, annotations).</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="string">
+							<attribute name="Type" use="required">
+								<annotation>
+									<documentation xml:lang="de">Beschreibungstyp.</documentation>
+									<documentation xml:lang="en">Description type.</documentation>
+								</annotation>
+								<simpleType>
+									<restriction base="token">
+										<enumeration value="Purpose">
+											<annotation>
+												<documentation xml:lang="de">Verwendungszweck</documentation>
+												<documentation xml:lang="en">remittance information.</documentation>
+											</annotation>
+										</enumeration>
+										<enumeration value="Details">
+											<annotation>
+												<documentation xml:lang="de">Auftragsdetails</documentation>
+												<documentation xml:lang="en">Order details.</documentation>
+											</annotation>
+										</enumeration>
+										<enumeration value="Comment">
+											<annotation>
+												<documentation xml:lang="de">Kommentar</documentation>
+												<documentation xml:lang="en">Annotation.</documentation>
+											</annotation>
+										</enumeration>
+									</restriction>
+								</simpleType>
+							</attribute>
+						</extension>
+					</simpleContent>
+				</complexType>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVTOrderFlagsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für HVT-Auftragsflags.</documentation>
+			<documentation xml:lang="en">Data type for HVT order flags.</documentation>
+		</annotation>
+		<attribute name="completeOrderData" type="boolean" use="required">
+			<annotation>
+				<documentation xml:lang="de">Sollen die Transaktionsdetails als Einzelauftragsinfos (completeOrderData=false) oder als komplette Originaldaten (completeOrderData=true) übertragen werden? (Vorschlag für Default=false)</documentation>
+				<documentation xml:lang="en">Are the transaction details so be transmitted as particular order content information requested for display matters or in complete order data file form? (Proposal for Default=false)</documentation>
+			</annotation>
+		</attribute>
+		<attribute name="fetchLimit" use="required">
+			<annotation>
+				<documentation xml:lang="de">Limit für die zu liefernden Transaktionsdetails, bei completeOrderData=false maximale Anzahl zu liefernder Einzelauftragsinfos, 0 für unbegrenzt (Vorschlag für Default=100).</documentation>
+				<documentation xml:lang="en">Limit for the transaction details to be transmitted; if completeOrderData=false, maximum number of details of a particular order; 0 for unlimited number of details (Proposal for Default=100).</documentation>
+			</annotation>
+			<simpleType>
+				<restriction base="nonNegativeInteger">
+					<totalDigits value="10"/>
+				</restriction>
+			</simpleType>
+		</attribute>
+		<attribute name="fetchOffset" use="required">
+			<annotation>
+				<documentation xml:lang="de">Offset vom Anfang der Originalauftragsdatei für die zu liefernden Transaktionsdetails, bei completeOrderData=false bezogen auf laufende Nummer des Einzelauftrags (Vorschlag für Default=0).</documentation>
+				<documentation xml:lang="en">Offset position in the original order file which marks the starting point for the transaction details to be transmitted; applies to the sequential number of a particular order if completeOrderData=false (Proposal for Default=0).</documentation>
+			</annotation>
+			<simpleType>
+				<restriction base="nonNegativeInteger">
+					<totalDigits value="10"/>
+				</restriction>
+			</simpleType>
+		</attribute>
+		<anyAttribute namespace="##targetNamespace" processContents="strict"/>
+	</complexType>
+	<complexType name="HVTOrderParamsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für zusätzliche Auftragsparameter für Auftragsart HVT.</documentation>
+			<documentation xml:lang="en">Data type for additional order parameters for order type HVT.</documentation>
+		</annotation>
+		<sequence>
+			<group ref="ebics:HVRequestStructure"/>
+			<element name="OrderFlags">
+				<annotation>
+					<documentation xml:lang="de">spezielle Flags für HVT-Aufträge.</documentation>
+					<documentation xml:lang="en">Special order flags for orders of type HVT.</documentation>
+				</annotation>
+				<complexType>
+					<complexContent>
+						<extension base="ebics:HVTOrderFlagsType"/>
+					</complexContent>
+				</complexType>
+			</element>
+			<element ref="ebics:Parameter" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Generische Schlüssel-Wert-Parameter</documentation>
+					<documentation xml:lang="en">Generic key-value parameters</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVUResponseOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HVU (Antwort: VEU-Übersicht abholen).</documentation>
+			<documentation xml:lang="en">Data type for order data for order type HVU (Response: Download EDS overview).</documentation>
+		</annotation>
+		<sequence>
+			<annotation>
+				<documentation xml:lang="de"/>
+			</annotation>
+			<element name="OrderDetails" type="ebics:HVUOrderDetailsType" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Auftragsinformationen.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVUOrderDetailsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für HVU-Auftragsdetails.</documentation>
+			<documentation xml:lang="en">Data type for HVU order details.</documentation>
+		</annotation>
+		<sequence>
+			<element name="Service" type="ebics:RestrictedServiceType">
+				<annotation>
+					<documentation xml:lang="de">Auftragsart lt. DFÜ-Abkommen des ausgewählten Auftrags.</documentation>
+					<documentation xml:lang="en">Type of the order.</documentation>
+				</annotation>
+			</element>
+			<element name="OrderID" type="ebics:OrderIDType">
+				<annotation>
+					<documentation xml:lang="de">Auftragsnummer lt. DFÜ-Abkommen des ausgewählten Auftrags.</documentation>
+					<documentation xml:lang="en">Order number.</documentation>
+				</annotation>
+			</element>
+			<element name="OrderDataSize" type="positiveInteger">
+				<annotation>
+					<documentation xml:lang="de">Größe der unkomprimierten Auftragsdaten in Bytes.</documentation>
+					<documentation xml:lang="en">Order data size in bytes.</documentation>
+				</annotation>
+			</element>
+			<element name="SigningInfo" type="ebics:HVUSigningInfoType">
+				<annotation>
+					<documentation xml:lang="de">Informationen zu den Unterschriftsmodalitäten.</documentation>
+					<documentation xml:lang="en">Signing information.</documentation>
+				</annotation>
+			</element>
+			<element name="SignerInfo" type="ebics:SignerInfoType" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Informationen zu den bisherigen Unterzeichnern.</documentation>
+					<documentation xml:lang="en">Information regarding the signer.</documentation>
+				</annotation>
+			</element>
+			<element name="OriginatorInfo" type="ebics:HVUOriginatorInfoType">
+				<annotation>
+					<documentation xml:lang="de">Informationen zum Einreicher.</documentation>
+					<documentation xml:lang="en">Information regarding the originator.</documentation>
+				</annotation>
+			</element>
+			<element name="AdditionalOrderInfo" type="ebics:String255Type" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Additional Information about the order (unstructured, up to 255 characters).</documentation>
+					<documentation xml:lang="en">Additional Information about the order (unstructured, up to 255 characters).</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVUOrderParamsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für zusätzliche Auftragsparameter für Auftragsart HVU.</documentation>
+			<documentation xml:lang="en">Data type for additional order parameters for order type HVU.</documentation>
+		</annotation>
+		<sequence>
+			<element name="ServiceFilter" type="ebics:ServiceType" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Liste von Auftragsarten, für die zur Unterschrift vorliegende Aufträge abgerufen werden sollen; falls nicht angegeben, werden sämtliche für den Teilnehmer unterschriftsfähigen Aufträge abgerufen.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVZOrderParamsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für zusätzliche Auftragsparameter für Auftragsart HVZ.</documentation>
+			<documentation xml:lang="en">Data type for additional order parameters for order type HVZ.</documentation>
+		</annotation>
+		<sequence>
+			<element name="ServiceFilter" type="ebics:ServiceType" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Liste von Auftragsarten, für die zur Unterschrift vorliegende Aufträge abgerufen werden sollen; falls nicht angegeben, werden sämtliche für den Teilnehmer unterschriftsfähigen Aufträge abgerufen.</documentation>
+					<documentation xml:lang="de">List of order types that the orders ready to be signed by the requesting user should match; if not specified, a list of all orders ready to be signed by the requesting user is returned.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVUSigningInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Informationen zu den HVU-Unterschriftsmodalitäten.</documentation>
+		</annotation>
+		<attribute name="readyToBeSigned" type="boolean" use="required">
+			<annotation>
+				<documentation xml:lang="de">Ist der Auftrag unterschriftsreif ("true") oder bereits vom Teilnehmer unterschrieben ("false")?</documentation>
+			</annotation>
+		</attribute>
+		<attribute name="NumSigRequired" type="positiveInteger" use="required">
+			<annotation>
+				<documentation xml:lang="de">Anzahl der insgesamt zur Freigabe erforderlichen EUs.</documentation>
+			</annotation>
+		</attribute>
+		<attribute name="NumSigDone" type="nonNegativeInteger" use="required">
+			<annotation>
+				<documentation xml:lang="de">Anzahl der bereits geleisteten EUs.</documentation>
+			</annotation>
+		</attribute>
+	</complexType>
+	<complexType name="HVUOriginatorInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Informationen zum Ersteller eines HVU-Auftrags.</documentation>
+		</annotation>
+		<sequence>
+			<element name="PartnerID" type="ebics:PartnerIDType">
+				<annotation>
+					<documentation xml:lang="de">Kunden-ID des Einreichers.</documentation>
+				</annotation>
+			</element>
+			<element name="UserID" type="ebics:UserIDType">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmer-ID des Einreichers.</documentation>
+				</annotation>
+			</element>
+			<element name="Name" type="ebics:NameType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Name des Einreichers.</documentation>
+				</annotation>
+			</element>
+			<element name="Timestamp" type="ebics:TimestampType">
+				<annotation>
+					<documentation xml:lang="de">Zeitstempel der Einreichung (d.h. der Übertragung der Auftragsdatei).</documentation>
+				</annotation>
+			</element>
+			<any namespace="##targetNamespace" processContents="strict" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVZResponseOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Auftragsdaten für Auftragsart HVZ (Antwort: VEU-Übersicht mit Zusatzinformationen abholen).</documentation>
+			<documentation xml:lang="en">Order data for order type HVZ (response: receive summary of orders currently stored in the distributed signature processing unit with additional informations).</documentation>
+		</annotation>
+		<sequence>
+			<annotation>
+				<documentation xml:lang="de"/>
+			</annotation>
+			<element name="OrderDetails" type="ebics:HVZOrderDetailsType" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Auftragsinformationen.</documentation>
+					<documentation xml:lang="en">Summary of order information.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="HVZOrderDetailsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für HVZ-Auftragsdetails.</documentation>
+		</annotation>
+		<sequence>
+			<element name="Service" type="ebics:RestrictedServiceType">
+				<annotation>
+					<documentation xml:lang="de">BTF Service Parameter-Struktur des ausgewählten Auftrags.</documentation>
+					<documentation xml:lang="en">Type of the order.</documentation>
+				</annotation>
+			</element>
+			<element name="OrderID" type="ebics:OrderIDType">
+				<annotation>
+					<documentation xml:lang="de">Auftragsnummer lt. DFÜ-Abkommen des ausgewählten Auftrags.</documentation>
+					<documentation xml:lang="en">ID number of the order.</documentation>
+				</annotation>
+			</element>
+			<element name="DataDigest" type="ebics:DataDigestType">
+				<annotation>
+					<documentation xml:lang="de">Hashwert der Auftragsdaten.</documentation>
+					<documentation xml:lang="en">Hash value of the order data.</documentation>
+				</annotation>
+			</element>
+			<element name="OrderDataAvailable" type="boolean">
+				<annotation>
+					<documentation xml:lang="de">Kann die Auftragsdatei im Originalformat abgeholt werden? (HVT mit completeOrderData=true).</documentation>
+					<documentation xml:lang="en">Can the order file be downloaded in the original format? (HVT with completeOrderData=true)</documentation>
+				</annotation>
+			</element>
+			<element name="OrderDataSize" type="positiveInteger">
+				<annotation>
+					<documentation xml:lang="de">Größe der unkomprimierten Auftragsdaten in Bytes.</documentation>
+					<documentation xml:lang="en">Size of uncompressed order data in Bytes.</documentation>
+				</annotation>
+			</element>
+			<element name="OrderDetailsAvailable" type="boolean">
+				<annotation>
+					<documentation xml:lang="de">Können die Auftragsdetails als XML-Dokument HVTResponseOrderData abgeholt werden? (HVT mit completeOrderData=false).</documentation>
+					<documentation xml:lang="en">Can the order details be downloaded as XML document HVTResponseOrderData?  (HVT with completeOrderData=false)</documentation>
+				</annotation>
+			</element>
+			<group ref="ebics:HVZPaymentOrderDetailsStructure" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Zusätzliche Auftragsdetails nur für Zahlungsaufträge.</documentation>
+					<documentation xml:lang="en">Order details related to payment orders only.</documentation>
+				</annotation>
+			</group>
+			<element name="SigningInfo" type="ebics:HVUSigningInfoType">
+				<annotation>
+					<documentation xml:lang="de">Informationen zu den Unterschriftsmodalitäten.</documentation>
+					<documentation xml:lang="en">Information regarding the signing modalities of the order.</documentation>
+				</annotation>
+			</element>
+			<element name="SignerInfo" type="ebics:SignerInfoType" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Informationen zu den bisherigen Unterzeichnern.</documentation>
+					<documentation xml:lang="en">Information regarding the users who already signed the order.</documentation>
+				</annotation>
+			</element>
+			<element name="OriginatorInfo" type="ebics:HVUOriginatorInfoType">
+				<annotation>
+					<documentation xml:lang="de">Informationen zum Einreicher.</documentation>
+					<documentation xml:lang="en">Information regarding the originator of the order.</documentation>
+				</annotation>
+			</element>
+			<element name="AdditionalOrderInfo" type="ebics:String255Type" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Additional Information about the order (unstructured, up to 255 characters).</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<group name="HVZPaymentOrderDetailsStructure">
+		<annotation>
+			<documentation xml:lang="de">Standard-Requeststruktur für HVx-Aufträge (HVD, HVT, HVE, HVS).</documentation>
+			<documentation xml:lang="en">Standard structure for HVZ OrderDetails related to payment orders</documentation>
+		</annotation>
+		<sequence>
+			<element name="TotalOrders" type="nonNegativeInteger" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Anzahl der Zahlungssätze über alle logische Dateien entsprechend Dateianzeige.</documentation>
+					<documentation xml:lang="en">Total transaction number for all logical files (from dispay file).</documentation>
+				</annotation>
+			</element>
+			<element name="TotalAmount" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Summe der Beträge über alle logische Dateien entsprechend Dateianzeige.</documentation>
+					<documentation xml:lang="en">Total transaction amount for all logical files (from dispay file).</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="ebics:AmountValueType">
+							<attribute name="isCredit" type="boolean" use="optional">
+								<annotation>
+									<documentation xml:lang="de">Nur Gutschriften (isCredit = "true") oder nur Lastschriften (isCredit = "false")? Sonst keine Nutzung des Elements.</documentation>
+								</annotation>
+							</attribute>
+						</extension>
+					</simpleContent>
+				</complexType>
+			</element>
+			<element name="Currency" type="ebics:CurrencyBaseType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Auftragswährung (nur bei sortenreinen Zahlungen, sonst keine Angabe).</documentation>
+					<documentation xml:lang="en">Order currency (only if identical across all transactions, ship otherwise).</documentation>
+				</annotation>
+			</element>
+			<element name="FirstOrderInfo" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Informationen aus Dateianzeige der ersten logischen Datei.</documentation>
+					<documentation xml:lang="en">Order details from display file for first logical file.</documentation>
+				</annotation>
+				<complexType>
+					<sequence>
+						<element name="OrderPartyInfo" type="normalizedString" minOccurs="0">
+							<annotation>
+								<documentation xml:lang="de">Auftraggeber entsprechend Dateianzeige.</documentation>
+								<documentation xml:lang="en">Order party information (from display file).</documentation>
+							</annotation>
+						</element>
+						<element name="AccountInfo" minOccurs="0">
+							<annotation>
+								<documentation xml:lang="de">Erstes Auftraggeberkonto entsprechend Dateianzeige.</documentation>
+								<documentation xml:lang="en">First order party account (from display file).</documentation>
+							</annotation>
+							<complexType>
+								<sequence>
+									<choice maxOccurs="2">
+										<element name="AccountNumber">
+											<annotation>
+												<documentation xml:lang="de">Kontonummer (deutsches Format oder international als IBAN).</documentation>
+												<documentation xml:lang="en">Account number (German format or international as IBAN).</documentation>
+											</annotation>
+											<complexType>
+												<simpleContent>
+													<extension base="ebics:AccountNumberType">
+														<attribute name="international" type="boolean" use="optional" default="false">
+															<annotation>
+																<documentation xml:lang="de">Ist die Kontonummer im deutschen Format (international=false) oder im internationalen Format (international=true, IBAN) angegeben?</documentation>
+																<documentation xml:lang="en">Account number given in German format (international=false) or in international format (international=true, IBAN)?</documentation>
+															</annotation>
+														</attribute>
+													</extension>
+												</simpleContent>
+											</complexType>
+										</element>
+										<element name="NationalAccountNumber">
+											<annotation>
+												<documentation xml:lang="de">Kontonummer im freien Format.</documentation>
+												<documentation xml:lang="en">Account number in free format.</documentation>
+											</annotation>
+											<complexType>
+												<simpleContent>
+													<extension base="ebics:NationalAccountNumberType">
+														<attribute name="format" type="token" use="required">
+															<annotation>
+																<documentation xml:lang="de">Formatkennung.</documentation>
+																<documentation xml:lang="en">Format type.</documentation>
+															</annotation>
+														</attribute>
+													</extension>
+												</simpleContent>
+											</complexType>
+										</element>
+									</choice>
+									<choice minOccurs="0" maxOccurs="2">
+										<element name="BankCode">
+											<annotation>
+												<documentation xml:lang="de">Bankleitzahl (deutsches Format oder international als SWIFT-BIC).</documentation>
+												<documentation xml:lang="en">Bank sort code (German format or international as SWIFT-BIC).</documentation>
+											</annotation>
+											<complexType>
+												<simpleContent>
+													<extension base="ebics:BankCodeType">
+														<attribute name="international" type="boolean" use="optional" default="false">
+															<annotation>
+																<documentation xml:lang="de">Ist die Bankleitzahl im deutschen Format (international=false, BLZ) oder im internationalen Format (international=true, SWIFT-BIC) angegeben?</documentation>
+																<documentation xml:lang="en">Bank sort code given in German format (international=false) or in international format (international=true, SWIFT-BIC)?</documentation>
+															</annotation>
+														</attribute>
+														<attribute name="Prefix" type="ebics:BankCodePrefixType" use="optional">
+															<annotation>
+																<documentation xml:lang="de">nationales Präfix für Bankleitzahlen.</documentation>
+																<documentation xml:lang="en">National prefix for bank sort code.</documentation>
+															</annotation>
+														</attribute>
+													</extension>
+												</simpleContent>
+											</complexType>
+										</element>
+										<element name="NationalBankCode">
+											<annotation>
+												<documentation xml:lang="de">Bankleitzahl im freien Format.</documentation>
+												<documentation xml:lang="en">Bank sort code in free format.</documentation>
+											</annotation>
+											<complexType>
+												<simpleContent>
+													<extension base="ebics:NationalBankCodeType">
+														<attribute name="format" type="token" use="required">
+															<annotation>
+																<documentation xml:lang="de">Formatkennung.</documentation>
+																<documentation xml:lang="en">Format type.</documentation>
+															</annotation>
+														</attribute>
+													</extension>
+												</simpleContent>
+											</complexType>
+										</element>
+									</choice>
+								</sequence>
+							</complexType>
+						</element>
+					</sequence>
+				</complexType>
+			</element>
+		</sequence>
+	</group>
+	<complexType name="SignerInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Informationen zu einem Unterzeichner eines VEU-Auftrags (HVU, HVD).</documentation>
+		</annotation>
+		<sequence>
+			<element name="PartnerID" type="ebics:PartnerIDType">
+				<annotation>
+					<documentation xml:lang="de">Kunden-ID des Unterzeichners.</documentation>
+				</annotation>
+			</element>
+			<element name="UserID" type="ebics:UserIDType">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmer-ID des Unterzeichners.</documentation>
+				</annotation>
+			</element>
+			<element name="Name" type="ebics:NameType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Name des Unterzeichners.</documentation>
+				</annotation>
+			</element>
+			<element name="Timestamp" type="ebics:TimestampType">
+				<annotation>
+					<documentation xml:lang="de">Zeitstempel der Unterzeichnung (d.h. der Übertragung der Unterschrift).</documentation>
+				</annotation>
+			</element>
+			<element name="Permission">
+				<annotation>
+					<documentation xml:lang="de">zusätzliche Informationen zu den Berechtigungen des Teilnehmers, der unterzeichnet hat.</documentation>
+				</annotation>
+				<complexType>
+					<attributeGroup ref="ebics:SignerPermission"/>
+				</complexType>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="UserPermissionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für VEU-Berechtigungsinformationen des Teilnehmers (HKD, HTD).</documentation>
+		</annotation>
+		<sequence>
+			<element name="AdminOrderType" type="ebics:OrderTBaseType">
+				<annotation>
+					<documentation xml:lang="de">Liste von Auftragsarten, für die die Berechtigung des Teilnehmers gültig ist.</documentation>
+					<documentation xml:lang="en">List of order types which the user's permission belongs to.</documentation>
+				</annotation>
+			</element>
+			<element name="Service" type="ebics:RestrictedServiceType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">BTF Service Parameter struktur im Falle von BTU/BTD</documentation>
+					<documentation xml:lang="en">Identification of the file format in the case of FUL/FDL</documentation>
+				</annotation>
+			</element>
+			<element name="AccountID" type="ebics:AccountIDType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Verweis auf den Identifikationscode des berechtigten Kontos.</documentation>
+					<documentation xml:lang="en">Identification codes of the affected accounts.</documentation>
+				</annotation>
+			</element>
+			<element name="MaxAmount" type="ebics:AmountType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Betragshöchstgrenze, bis zu der die Berechtigung des Teilnehmers gültig ist.</documentation>
+					<documentation xml:lang="en">Maximum total amount which the user's permission is valid for.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+		<attribute name="AuthorisationLevel" type="ebics:AuthorisationLevelType">
+			<annotation>
+				<documentation xml:lang="de">Unterschriftsklasse, für die der Teilnehmer berechtigt ist; nicht anzugeben bei Download-Auftragsarten.</documentation>
+				<documentation xml:lang="en">Authorization level of the user who signed the order; to be omitted for orders of type "download".</documentation>
+			</annotation>
+		</attribute>
+		<anyAttribute namespace="##targetNamespace" processContents="strict"/>
+	</complexType>
+	<complexType name="PartnerInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für VEU-Partnerdaten (HKD, HTD).</documentation>
+			<documentation xml:lang="en">Data type for customer data with regard to distributed signatures (order types HKD, HTD).</documentation>
+		</annotation>
+		<sequence>
+			<element name="AddressInfo" type="ebics:AddressInfoType">
+				<annotation>
+					<documentation xml:lang="de">Informationen zur Adresse des Kunden.</documentation>
+					<documentation xml:lang="en">Information about the customer's adress.</documentation>
+				</annotation>
+			</element>
+			<element name="BankInfo" type="ebics:BankInfoType">
+				<annotation>
+					<documentation xml:lang="de">Informationen zur Kreditinstitutsanbindung des Kunden.</documentation>
+					<documentation xml:lang="en">Information about the customer's banking access paramters.</documentation>
+				</annotation>
+			</element>
+			<element name="AccountInfo" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Informationen zu den Konten des Kunden.</documentation>
+					<documentation xml:lang="en">Information about the customer's accounts.</documentation>
+				</annotation>
+				<complexType>
+					<complexContent>
+						<extension base="ebics:AccountType">
+							<sequence>
+								<element name="UsageOrderTypes" type="ebics:UsageOrderType" minOccurs="0">
+									<annotation>
+										<documentation xml:lang="de">//MODIFIED//Liste der Auftragsartenbeschränkungen; falls nicht angegeben, gibt es keine Auftragsartenbeschränkungen; falls das Element ohne Service-Element geliefert wird, ist das Konto für keine Auftragsart freigegeben.</documentation>
+										<documentation xml:lang="en">List containing the order types which contain this account is restricted to; if omitted, the account is unrestricted; if the list is empty the account is blocked for any order type.</documentation>
+									</annotation>
+								</element>
+								<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+							</sequence>
+							<attribute name="ID" type="ebics:AccountIDType" use="required">
+								<annotation>
+									<documentation xml:lang="de">Identifikationscode des Kontos.</documentation>
+								</annotation>
+							</attribute>
+						</extension>
+					</complexContent>
+				</complexType>
+			</element>
+			<element name="OrderInfo" type="ebics:AuthOrderInfoType" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Informationen zu den Auftragsarten, für die der Kunde berechtigt ist.</documentation>
+					<documentation xml:lang="en">Information about order types which the customer is authorised to use.</documentation>
+				</annotation>
+			</element>
+		</sequence>
+	</complexType>
+	<complexType name="AddressInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für VEU-Adressinformationen (HKD, HTD).</documentation>
+			<documentation xml:lang="en">Data type for address information with regard to distributed signature (order types HKD, HTD).</documentation>
+		</annotation>
+		<sequence>
+			<element name="Name" type="ebics:NameType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Name des Kunden.</documentation>
+					<documentation xml:lang="en">Customer's name.</documentation>
+				</annotation>
+			</element>
+			<element name="Street" type="ebics:NameType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Straße und Hausnummer.</documentation>
+					<documentation xml:lang="en">Street and house number.</documentation>
+				</annotation>
+			</element>
+			<element name="PostCode" type="token" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Postleitzahl.</documentation>
+					<documentation xml:lang="en">Postal code.</documentation>
+				</annotation>
+			</element>
+			<element name="City" type="ebics:NameType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Stadt.</documentation>
+					<documentation xml:lang="en">City.</documentation>
+				</annotation>
+			</element>
+			<element name="Region" type="ebics:NameType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Region / Bundesland / Bundesstaat.</documentation>
+					<documentation xml:lang="en">Region / province / federal state.</documentation>
+				</annotation>
+			</element>
+			<element name="Country" type="ebics:NameType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Land.</documentation>
+					<documentation xml:lang="en">Country.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="BankInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für VEU-Kreditinstitutsinformationen (HKD, HTD).</documentation>
+		</annotation>
+		<sequence>
+			<element name="HostID" type="ebics:HostIDType">
+				<annotation>
+					<documentation xml:lang="de">Banksystem-ID.</documentation>
+				</annotation>
+			</element>
+			<element ref="ebics:Parameter" minOccurs="0" maxOccurs="unbounded"/>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="UserInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für VEU-Teilnehmerinformationen (HKD, HTD).</documentation>
+		</annotation>
+		<sequence>
+			<element name="UserID">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmer-ID.</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="ebics:UserIDType">
+							<attribute name="Status" type="ebics:UserStatusType" use="required">
+								<annotation>
+									<documentation xml:lang="de">Status des Teilnehmers.</documentation>
+								</annotation>
+							</attribute>
+						</extension>
+					</simpleContent>
+				</complexType>
+			</element>
+			<element name="Name" type="ebics:NameType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Name des Teilnehmers.</documentation>
+				</annotation>
+			</element>
+			<element name="Permission" type="ebics:UserPermissionType" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">Informationen zu den Berechtigungen des Teilnehmers.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="AuthOrderInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für VEU-Berechtigungsinformationen zu Auftragsarten (HKD, HTD).</documentation>
+			<documentation xml:lang="en">Data type for user permissions with regard to distributed signatures (order types HKD, HTD).</documentation>
+		</annotation>
+		<sequence>
+			<element name="AdminOrderType" type="ebics:OrderTBaseType">
+				<annotation>
+					<documentation xml:lang="de">Administrative EBICS Auftragsart.</documentation>
+				</annotation>
+			</element>
+			<element name="Service" type="ebics:RestrictedServiceType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">BTF Service Parameter struktur im Falle von BTU/BTD</documentation>
+					<documentation xml:lang="en">Identification of the file format in the case of FUL/FDL</documentation>
+				</annotation>
+			</element>
+			<element name="Description" type="ebics:OrderDescriptionType">
+				<annotation>
+					<documentation xml:lang="de">Beschreibung der Auftragsart.</documentation>
+				</annotation>
+			</element>
+			<element name="NumSigRequired" type="nonNegativeInteger" default="0" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Anzahl erforderlicher EUs (Default=0).</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="StandardOrderParamsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für zusätzliche Auftragsparameter bei Standard-Auftragsarten.</documentation>
+		</annotation>
+		<sequence>
+			<element name="DateRange" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Datumsbereich (von-bis).</documentation>
+				</annotation>
+				<complexType>
+					<sequence>
+						<element name="Start" type="ebics:DateType">
+							<annotation>
+								<documentation xml:lang="de">Startdatum (inkl.).</documentation>
+							</annotation>
+						</element>
+						<element name="End" type="ebics:DateType">
+							<annotation>
+								<documentation xml:lang="de">Enddatum (inkl.).</documentation>
+							</annotation>
+						</element>
+					</sequence>
+				</complexType>
+			</element>
+		</sequence>
+	</complexType>
+	<attributeGroup name="VersionAttrGroup">
+		<annotation>
+			<documentation xml:lang="de">Attribute zur EBICS-Protokollversion und -revision.</documentation>
+			<documentation xml:lang="en">Attributes regarding the protocol version and revision of EBICS.</documentation>
+		</annotation>
+		<attribute name="Version" type="ebics:ProtocolVersionType" use="required">
+			<annotation>
+				<documentation xml:lang="de">Version des EBICS-Protokolls (z.B. "H00x").</documentation>
+				<documentation xml:lang="en">Version of the EBICS protocol (e.g. "H00x").</documentation>
+			</annotation>
+		</attribute>
+		<attribute name="Revision" type="ebics:ProtocolRevisionType" use="optional">
+			<annotation>
+				<documentation xml:lang="de">Revision des EBICS-Protokolls (z.B. 1).</documentation>
+				<documentation xml:lang="en">Revision of the EBICS protocol (e.g. 1).</documentation>
+			</annotation>
+		</attribute>
+	</attributeGroup>
+	<!--Following ComplexTypes are used for BTF-->
+	<element name="BTDOrderParams" type="ebics:BTDParamsType" substitutionGroup="ebics:OrderParams">
+		<annotation>
+			<documentation>zusätzliche Auftragsparameter für Auftragsart BTD.</documentation>
+			<documentation xml:lang="en">additional order parameters for order type BTD.</documentation>
+		</annotation>
+	</element>
+	<element name="BTUOrderParams" type="ebics:BTUParamsType" substitutionGroup="ebics:OrderParams">
+		<annotation>
+			<documentation>zusätzliche Auftragsparameter für Auftragsart BTU.</documentation>
+			<documentation xml:lang="en">additional order parameters for order type BTU.</documentation>
+		</annotation>
+	</element>
+	<complexType name="BTDParamsType">
+		<annotation>
+			<documentation>Datentyp für BTF Download Parameter</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:BTFParamsTyp">
+				<sequence>
+					<element name="Service" type="ebics:RestrictedServiceType">
+						<annotation>
+							<documentation>Service name - target system for the further processing of the order</documentation>
+						</annotation>
+					</element>
+					<element name="DateRange" type="ebics:DateRangeType" minOccurs="0"/>
+					<element ref="ebics:Parameter" minOccurs="0" maxOccurs="unbounded"/>
+				</sequence>
+				<attribute name="fileName" type="ebics:FileNameStringType" use="prohibited">
+					<annotation>
+						<documentation>The file name on the client It can be transmitted optionally</documentation>
+					</annotation>
+				</attribute>
+			</restriction>
+		</complexContent>
+	</complexType>
+	<complexType name="BTUParamsType">
+		<annotation>
+			<documentation>Datentyp für BTF Upload Parameter</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:BTFParamsTyp">
+				<sequence>
+					<element name="Service" type="ebics:RestrictedServiceType">
+						<annotation>
+							<documentation>Service name - target system for the further processing of the order</documentation>
+						</annotation>
+					</element>
+					<element name="SignatureFlag" type="ebics:SignatureFlagType" minOccurs="0">
+						<annotation>
+							<documentation>If not present the order doesn't contain any ES and shall be authorised outside EBICS
+If present the order shall be autorised within EBICS: 
+1. If the attribute VEU is also present the sender desires spooling into the VEU - hence in this case the order is not rejected in the case of not sufficient number of ES
+2. If the attribute is not present all necessary ES must be inside the order (else: rejection of the order)  </documentation>
+						</annotation>
+					</element>
+					<element ref="ebics:Parameter" minOccurs="0" maxOccurs="unbounded"/>
+				</sequence>
+				<attribute name="fileName" type="ebics:FileNameStringType">
+					<annotation>
+						<documentation>The file name on the client It can be transmitted optionally</documentation>
+					</annotation>
+				</attribute>
+			</restriction>
+		</complexContent>
+	</complexType>
+	<complexType name="BTFParamsTyp" abstract="true">
+		<annotation>
+			<documentation>Abstract Type containing all BTF params structures</documentation>
+		</annotation>
+		<sequence>
+			<element name="Service" type="ebics:RestrictedServiceType">
+				<annotation>
+					<documentation>Service name - target system for the further processing of the order</documentation>
+				</annotation>
+			</element>
+			<element name="SignatureFlag" type="ebics:SignatureFlagType" minOccurs="0">
+				<annotation>
+					<documentation>If not present the order doesn't contain any ES and shall be authorised outside EBICS
+If present the order shall be autorised within EBICS: 
+1. If the attribute VEU is also present the sender desires spooling into the VEU - hence in this case the order is not rejected in the case of not sufficient number of ES
+2. If the attribute is not present all necessary ES must be inside the order (else: rejection of the order)  </documentation>
+				</annotation>
+			</element>
+			<element name="DateRange" type="ebics:DateRangeType" minOccurs="0"/>
+			<element ref="ebics:Parameter" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+		<attribute name="fileName" type="ebics:FileNameStringType">
+			<annotation>
+				<documentation>The file name on the client It can be transmitted optionally</documentation>
+			</annotation>
+		</attribute>
+	</complexType>
+	<complexType name="DateRangeType">
+		<annotation>
+			<documentation>Datentyp für die Angabe eines (Berichts-) Zeitraums</documentation>
+		</annotation>
+		<sequence>
+			<element name="Start" type="ebics:DateType"/>
+			<element name="End" type="ebics:DateType"/>
+		</sequence>
+	</complexType>
+	<complexType name="FlagAttribType">
+		<annotation>
+			<documentation>Basis-Datentyp für Kennzeichen mit optionalem Attribut</documentation>
+		</annotation>
+		<anyAttribute/>
+	</complexType>
+	<complexType name="MessageType">
+		<annotation>
+			<documentation>Datentyp für Meldungstyp-String mit optionalen Attributen</documentation>
+		</annotation>
+		<simpleContent>
+			<extension base="ebics:MessageNameStringType">
+				<attribute name="variant" type="ebics:NumStringType" use="optional">
+					<annotation>
+						<documentation>Variant number of the message type (usable for ISO20022 messages)</documentation>
+					</annotation>
+				</attribute>
+				<attribute name="version" type="ebics:NumStringType" use="optional">
+					<annotation>
+						<documentation>Version number of the message type  (usable for ISO20022 messages)</documentation>
+					</annotation>
+				</attribute>
+				<attribute name="format" use="optional">
+					<annotation>
+						<documentation>Encoding format of the message (e.g. XML, ASN1, JSON, PDF)</documentation>
+					</annotation>
+					<simpleType>
+						<restriction base="ebics:CodeStringType">
+							<maxLength value="4"/>
+						</restriction>
+					</simpleType>
+				</attribute>
+			</extension>
+		</simpleContent>
+	</complexType>
+	<complexType name="ServiceType">
+		<annotation>
+			<documentation>Basisdatentyp für BTF-Service Parameter Set</documentation>
+		</annotation>
+		<sequence>
+			<element name="ServiceName" type="ebics:ServiceNameStringType" minOccurs="0">
+				<annotation>
+					<documentation>Service Code name: External list specified and maintained by EBICS. Basis is the "SWIFT-list" for the field "description" (SCT, DCT, XCT, SDD, DDD, STM, REP...) plus additional codes needed for further services </documentation>
+				</annotation>
+			</element>
+			<element name="Scope" type="ebics:ScopeStringType" minOccurs="0">
+				<annotation>
+					<documentation>Specifies whose rules have to be taken into account for the service. This means which market / comminity has defined the rules. 
+If the element is absent a global definition for the service is assumed.
+External list specified and maintained by EBICS. In addition the following codes may be used:
+2-character ISO country code or a 3-character issuer code (defined by EBICS)</documentation>
+				</annotation>
+			</element>
+			<element name="ServiceOption" type="ebics:ServiceOptionStringType" minOccurs="0">
+				<annotation>
+					<documentation>Service Option Code
+Additional option for the service (also depends on used scope)</documentation>
+				</annotation>
+			</element>
+			<element name="Container" type="ebics:ContainerFlagType" minOccurs="0">
+				<annotation>
+					<documentation>Container flag. If present, data is provided/requested in a container format specified in the attribute of the flag</documentation>
+				</annotation>
+			</element>
+			<element name="MsgName" type="ebics:MessageType" minOccurs="0">
+				<annotation>
+					<documentation>Name of the message, e.g. pain.001 or mt101 National message names (issued by DK, CFONB or SIC are also allowed)</documentation>
+				</annotation>
+			</element>
+		</sequence>
+	</complexType>
+	<complexType name="RestrictedServiceType">
+		<annotation>
+			<documentation>Type is arestriction of the generic ServiceType, defining the mandatory elements</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:ServiceType">
+				<sequence>
+					<element name="ServiceName" type="ebics:ServiceNameStringType">
+						<annotation>
+							<documentation>Service Code name: External list specified and maintained by EBICS. Basis is the "SWIFT-list" for the field "description" (SCT, DCT, XCT, SDD, DDD, STM, REP...) plus additional codes needed for further services </documentation>
+						</annotation>
+					</element>
+					<element name="Scope" type="ebics:ScopeStringType" minOccurs="0">
+						<annotation>
+							<documentation>Specifies whose rules have to be taken into account for the service. This means which market / comminity has defined the rules. 
+If the element is absent a global definition for the service is assumed.
+External list specified and maintained by EBICS.
+In addition the following codes may be used:        
+2-character ISO country code or a 3-character issuer code (defined by EBICS)</documentation>
+						</annotation>
+					</element>
+					<element name="ServiceOption" type="ebics:ServiceOptionStringType" minOccurs="0">
+						<annotation>
+							<documentation>Service Option Code
+		Additional option for the service (also depends on used scope)</documentation>
+						</annotation>
+					</element>
+					<element name="Container" type="ebics:ContainerFlagType" minOccurs="0">
+						<annotation>
+							<documentation>Container flag. If present, data is provided/requested in a container format specified in the attribute of the flag</documentation>
+						</annotation>
+					</element>
+					<element name="MsgName" type="ebics:MessageType">
+						<annotation>
+							<documentation>Name of the message, e.g. pain.001 or mt101 National message names (issued by DK, CFONB or SIC are also allowed)</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</restriction>
+		</complexContent>
+	</complexType>
+	<complexType name="ContainerFlagType">
+		<annotation>
+			<documentation>Container flag. If present, data is provided/requested in a container format specified in the attribute of the flag</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:FlagAttribType">
+				<attribute name="containerType" type="ebics:ContainerStringType" use="required">
+					<annotation>
+						<documentation>Specifies the container type  - External Codelist defined by EBICS (starting values: XML, ZIP, SVC)</documentation>
+					</annotation>
+				</attribute>
+			</restriction>
+		</complexContent>
+	</complexType>
+	<complexType name="SignatureFlagType">
+		<annotation>
+			<documentation>Datentyp für BTF Signatur-Flag (ersetzt Orderkennzeichen)</documentation>
+		</annotation>
+		<complexContent>
+			<restriction base="ebics:FlagAttribType">
+				<attribute name="requestEDS" type="boolean" use="optional">
+					<annotation>
+						<documentation>If present the sender desires spooling into EBICS distributed signature queue, only "true" is allowed</documentation>
+					</annotation>
+				</attribute>
+			</restriction>
+		</complexContent>
+	</complexType>
+	<complexType name="UsageOrderType">
+		<annotation>
+			<documentation>Datentyp zur Kennzeichnung von Auftragsartenbeschränkungen</documentation>
+		</annotation>
+		<sequence>
+			<element name="Service" type="ebics:RestrictedServiceType" minOccurs="0" maxOccurs="unbounded">
+				<annotation>
+					<documentation>Service Parameter-Sets von nicht unterstützten BTF-Auftragsarten</documentation>
+				</annotation>
+			</element>
+		</sequence>
+	</complexType>
+	<!--END BTF-->
+</schema>
diff --git a/spec/xsd/ebics_request_H005.xsd b/spec/xsd/ebics_request_H005.xsd
new file mode 100644
index 00000000..dc7ad70a
--- /dev/null
+++ b/spec/xsd/ebics_request_H005.xsd
@@ -0,0 +1,349 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- edited with XMLSpy v2016 sp1 (x64) (http://www.altova.com) by EBICS Working Group - March 2017 -->
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:ebics="urn:org:ebics:H005" targetNamespace="urn:org:ebics:H005" elementFormDefault="qualified" attributeFormDefault="unqualified" version="1.0">
+	<annotation>
+		<documentation xml:lang="de">ebics_request_H005.xsd ist das EBICS-Protokollschema für Anfragen.</documentation>
+		<documentation xml:lang="en">ebics_request_H005.xsd is the appropriate EBICS protocol schema for standard requests.</documentation>
+	</annotation>
+	<include schemaLocation="ebics_types_H005.xsd"/>
+	<include schemaLocation="ebics_orders_H005.xsd"/>
+	<import namespace="http://www.w3.org/2000/09/xmldsig#" schemaLocation="xmldsig-core-schema.xsd"/>
+	<element name="ebicsRequest">
+		<annotation>
+			<documentation xml:lang="de">Electronic Banking Internet Communication Standard of the EBICS SCRL: Multibankfähige Schnittstelle zur internetbasierten Kommunikation.</documentation>
+			<documentation xml:lang="en">Electronic Banking Internet Communication Standard der EBICS SCRL: multi-bank capable interface for internet-based communication.</documentation>
+		</annotation>
+		<complexType>
+			<sequence>
+				<element name="header">
+					<annotation>
+						<documentation xml:lang="de">enthält die technischen Transaktionsdaten.</documentation>
+						<documentation xml:lang="en">contains the transaction-driven data.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<element name="static" type="ebics:StaticHeaderType">
+								<annotation>
+									<documentation xml:lang="de">enhält alle festen Headereinträge.</documentation>
+									<documentation xml:lang="en">contains the static header entries.</documentation>
+								</annotation>
+							</element>
+							<element name="mutable" type="ebics:MutableHeaderType">
+								<annotation>
+									<documentation xml:lang="de">enthält alle variablen Headereinträge.</documentation>
+									<documentation xml:lang="en">contains the mutable header entries.</documentation>
+								</annotation>
+							</element>
+						</sequence>
+						<attributeGroup ref="ebics:AuthenticationMarker"/>
+					</complexType>
+				</element>
+				<element ref="ebics:AuthSignature"/>
+				<element name="body">
+					<annotation>
+						<documentation xml:lang="de">enthält die Auftragsdaten, EU(s) und weitere Nutzdaten.</documentation>
+						<documentation xml:lang="en">contains order data, order signature(s) and further data referring to the current order.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<annotation>
+								<documentation xml:lang="de"/>
+							</annotation>
+							<element ref="ds:X509Data" minOccurs="0" maxOccurs="0">
+								<annotation>
+									<documentation xml:lang="de">X.509-Daten des Teilnehmers.</documentation>
+									<documentation xml:lang="en">X.509 data of the user.</documentation>
+								</annotation>
+							</element>
+							<choice>
+								<annotation>
+									<documentation xml:lang="de">Welche Transaktionsphase?</documentation>
+									<documentation xml:lang="en">Which transaction phase?</documentation>
+								</annotation>
+								<sequence>
+									<annotation>
+										<documentation xml:lang="de">Initialisierungs- und Transferphase.</documentation>
+										<documentation xml:lang="en">Initialisation or transfer phase.</documentation>
+									</annotation>
+									<element name="PreValidation" minOccurs="0">
+										<annotation>
+											<documentation xml:lang="de">Daten zur Vorabprüfung; nur anzugeben in der Initialisierungsphase bei Uploads mit Auftragsattribut OZH (EUs + Auftragsdaten).</documentation>
+											<documentation xml:lang="en">Data sent for pre-validation; mandatory for initialisation phase during uploads using order attribute OZH (order signature(s) + order data).</documentation>
+										</annotation>
+										<complexType>
+											<complexContent>
+												<extension base="ebics:PreValidationRequestType">
+													<attributeGroup ref="ebics:AuthenticationMarker"/>
+												</extension>
+											</complexContent>
+										</complexType>
+									</element>
+									<element name="DataTransfer" type="ebics:DataTransferRequestType" minOccurs="0">
+										<annotation>
+											<documentation xml:lang="de">Transfer von Signatur- bzw. Auftragsdaten; nur bei Upload anzugeben.</documentation>
+											<documentation xml:lang="en">Transfer of signature or order data; mandatory for uploads only.</documentation>
+										</annotation>
+									</element>
+								</sequence>
+								<sequence>
+									<annotation>
+										<documentation xml:lang="de">Quittierungsphase nach Download.</documentation>
+										<documentation xml:lang="en">Receipt phase after download.</documentation>
+									</annotation>
+									<element name="TransferReceipt">
+										<annotation>
+											<documentation xml:lang="de">Quittierung des Transfers.</documentation>
+											<documentation xml:lang="en">Receipt of transfer.</documentation>
+										</annotation>
+										<complexType>
+											<complexContent>
+												<extension base="ebics:TransferReceiptRequestType">
+													<attributeGroup ref="ebics:AuthenticationMarker"/>
+												</extension>
+											</complexContent>
+										</complexType>
+									</element>
+								</sequence>
+							</choice>
+						</sequence>
+					</complexType>
+				</element>
+			</sequence>
+			<attributeGroup ref="ebics:VersionAttrGroup"/>
+			<anyAttribute namespace="##targetNamespace" processContents="strict"/>
+		</complexType>
+	</element>
+	<complexType name="StaticHeaderType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den statischen EBICS-Header.</documentation>
+			<documentation xml:lang="en">Data type for the static EBICS header.</documentation>
+		</annotation>
+		<sequence>
+			<element name="HostID" type="ebics:HostIDType">
+				<annotation>
+					<documentation xml:lang="de">Hostname des Banksystems.</documentation>
+				</annotation>
+			</element>
+			<choice>
+				<annotation>
+					<documentation xml:lang="de">Transaktionsphase?</documentation>
+					<documentation xml:lang="en">Transaction phase?</documentation>
+				</annotation>
+				<sequence>
+					<annotation>
+						<documentation xml:lang="de">Initialisierungsphase.</documentation>
+						<documentation xml:lang="en">Initialisation phase.</documentation>
+					</annotation>
+					<element name="Nonce" type="ebics:NonceType">
+						<annotation>
+							<documentation xml:lang="de">Zufallswert; damit wird die Initialisierungsnachricht des Clients einzigartig.</documentation>
+							<documentation xml:lang="en">Random value, ensures the uniqueness of the client's message during initialisation phase.</documentation>
+						</annotation>
+					</element>
+					<element name="Timestamp" type="ebics:TimestampType">
+						<annotation>
+							<documentation xml:lang="de">aktueller Zeitstempel zur Begrenzung der serverseitigen Nonce-Speicherung.</documentation>
+							<documentation xml:lang="en">current timestamp, used to limit storage space for nonces on the server.</documentation>
+						</annotation>
+					</element>
+					<element name="PartnerID" type="ebics:PartnerIDType">
+						<annotation>
+							<documentation xml:lang="de">Kunden-ID des serverseitig administrierten Kunden.</documentation>
+							<documentation xml:lang="en">ID of the partner = customer, administered on the server.</documentation>
+						</annotation>
+					</element>
+					<element name="UserID" type="ebics:UserIDType">
+						<annotation>
+							<documentation xml:lang="de">Teilnehmer-ID des serverseitig zu diesem Kunden administrierten Teilnehmers.</documentation>
+							<documentation xml:lang="en">ID of the user that is assigned to the given customer, administered on the server.</documentation>
+						</annotation>
+					</element>
+					<element name="SystemID" type="ebics:UserIDType" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">technische User-ID für Multi-User-Systeme.</documentation>
+							<documentation xml:lang="en">ID of the system for multi-user systems.</documentation>
+						</annotation>
+					</element>
+					<element name="Product" nillable="true" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">Kennung des Kundenprodukts bzw. Herstellerkennung oder Name.</documentation>
+							<documentation xml:lang="en">software ID / manufacturer ID / manufacturer's name of the customer's software package.</documentation>
+						</annotation>
+						<complexType>
+							<simpleContent>
+								<extension base="ebics:ProductType">
+									<attribute name="Language" type="ebics:LanguageType" use="required">
+										<annotation>
+											<documentation xml:lang="de">Sprachkennzeichen der Kundenproduktversion (gemäß ISO 639).</documentation>
+											<documentation xml:lang="en">Language code of the customer's software package according to ISO 639.</documentation>
+										</annotation>
+									</attribute>
+									<attribute name="InstituteID" type="ebics:InstituteIDType" use="optional">
+										<annotation>
+											<documentation xml:lang="de">Kennung des Herausgebers des Kundenprodukts bzw. des betreuenden Kreditinstituts.</documentation>
+											<documentation xml:lang="en">ID of the manufacturer / financial institute providing support for the customer's software package.</documentation>
+										</annotation>
+									</attribute>
+								</extension>
+							</simpleContent>
+						</complexType>
+					</element>
+					<element name="OrderDetails" type="ebics:StaticHeaderOrderDetailsType">
+						<annotation>
+							<documentation xml:lang="de">Auftragsdetails.</documentation>
+							<documentation xml:lang="en">order details.</documentation>
+						</annotation>
+					</element>
+					<element name="BankPubKeyDigests">
+						<annotation>
+							<documentation xml:lang="de">Hashwerte der erwarteten öffentlichen Schlüssel (Verschlüsselung, Signatur, Authentifikation) des Kreditinstituts.</documentation>
+							<documentation xml:lang="en">Digest values of the expected public keys (authentication, encryption, signature) owned by the financial institute.</documentation>
+						</annotation>
+						<complexType>
+							<sequence>
+								<element name="Authentication">
+									<annotation>
+										<documentation xml:lang="de">Hashwert des Authentifikationsschlüssels.</documentation>
+										<documentation xml:lang="en">Digest value of the public authentication key.</documentation>
+									</annotation>
+									<complexType>
+										<simpleContent>
+											<extension base="ebics:PubKeyDigestType">
+												<attribute name="Version" type="ebics:AuthenticationVersionType" use="required">
+													<annotation>
+														<documentation xml:lang="de">Version des Authentifikationsverfahrens.</documentation>
+														<documentation xml:lang="en">Version of the algorithm used for authentication.</documentation>
+													</annotation>
+												</attribute>
+											</extension>
+										</simpleContent>
+									</complexType>
+								</element>
+								<element name="Encryption">
+									<annotation>
+										<documentation xml:lang="de">Hashwert des Verschlüsselungsschlüssels.</documentation>
+										<documentation xml:lang="en">Digest value of the public encryption key.</documentation>
+									</annotation>
+									<complexType>
+										<simpleContent>
+											<extension base="ebics:PubKeyDigestType">
+												<attribute name="Version" type="ebics:EncryptionVersionType" use="required">
+													<annotation>
+														<documentation xml:lang="de">Version des Verschlüsselungsverfahrens.</documentation>
+														<documentation xml:lang="en">Version of the algorithm used for encryption.</documentation>
+													</annotation>
+												</attribute>
+											</extension>
+										</simpleContent>
+									</complexType>
+								</element>
+								<element name="Signature" minOccurs="0" maxOccurs="0">
+									<annotation>
+										<documentation xml:lang="de">Hashwert des Signaturschlüssels.</documentation>
+										<documentation xml:lang="en">Digest value of the public signature key.</documentation>
+									</annotation>
+									<complexType>
+										<simpleContent>
+											<extension base="ebics:PubKeyDigestType">
+												<attribute name="Version" type="ebics:SignatureVersionType" use="required">
+													<annotation>
+														<documentation xml:lang="de">Version des Signaturverfahrens.</documentation>
+														<documentation xml:lang="en">Version of the algorithm used for signature creation.</documentation>
+													</annotation>
+												</attribute>
+											</extension>
+										</simpleContent>
+									</complexType>
+								</element>
+							</sequence>
+						</complexType>
+					</element>
+					<element name="SecurityMedium" type="ebics:SecurityMediumType">
+						<annotation>
+							<documentation xml:lang="de">Angabe des Sicherheitsmediums, das der Kunde verwendet.</documentation>
+							<documentation xml:lang="en">Classification of the security medium used by the customer.</documentation>
+						</annotation>
+					</element>
+					<element name="NumSegments" type="ebics:NumSegmentsType" minOccurs="0">
+						<annotation>
+							<documentation xml:lang="de">Gesamtsegmentanzahl für diese Transaktion; nur bei Uploads anzugeben.</documentation>
+							<documentation xml:lang="en">Total number of segments for this transaction; mandatory for uploads only.</documentation>
+						</annotation>
+					</element>
+					<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+				</sequence>
+				<sequence>
+					<annotation>
+						<documentation xml:lang="de">Transfer- und Quittierungsphase.</documentation>
+						<documentation xml:lang="en">Transfer or receipt phase.</documentation>
+					</annotation>
+					<element name="TransactionID" type="ebics:TransactionIDType">
+						<annotation>
+							<documentation xml:lang="de">eindeutige, technische Transaktions-ID; wird vom Server vergeben.</documentation>
+							<documentation xml:lang="en">unique transaction ID, provided by the server.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</choice>
+		</sequence>
+	</complexType>
+	<complexType name="MutableHeaderType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den variablen EBICS-Header.</documentation>
+			<documentation xml:lang="en">Data type for the mutable EBICS header.</documentation>
+		</annotation>
+		<sequence>
+			<element name="TransactionPhase" type="ebics:TransactionPhaseType">
+				<annotation>
+					<documentation xml:lang="de">Phase, in der sich die Transaktion gerade befindet; wird bei jedem Transaktionsschritt vom Client gesetzt und vom Server übernommen.</documentation>
+					<documentation xml:lang="en">Current phase of the transaction; this information is provided by the client for each step of the transaction, and the server adopts the setting.</documentation>
+				</annotation>
+			</element>
+			<element name="SegmentNumber" nillable="true" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">enthält die Nummer des aktuellen Segments, welches gerade übertragen oder angefordert wird; nur anzugeben bei TransactionPhase=Transfer.</documentation>
+					<documentation xml:lang="en">contains the number of the segment which is currently being transmitted or requested; mandatory for transaction phase 'Transfer' only.</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="ebics:SegmentNumberType">
+							<attribute name="lastSegment" type="boolean" use="required">
+								<annotation>
+									<documentation xml:lang="de">Ist dies das letzte Segment der Übertragung?</documentation>
+									<documentation xml:lang="en">Is this segment meant to be the last one regarding this transmission?</documentation>
+								</annotation>
+							</attribute>
+						</extension>
+					</simpleContent>
+				</complexType>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="StaticHeaderOrderDetailsType">
+		<annotation>
+			<documentation xml:lang="de">//MODIFIED - Removed OrderAtribute ELEMENT// Datentyp für Auftragsdetails im statischen EBICS-Header.</documentation>
+			<documentation xml:lang="en">Data type for order details stored in the static EBICS header.</documentation>
+		</annotation>
+		<sequence>
+			<element name="AdminOrderType">
+				<annotation>
+					<documentation xml:lang="de">//MODIFIED - Umbenannt von OrderType// Auftragsart.</documentation>
+					<documentation xml:lang="en">type code of the order.</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="ebics:OrderTBaseType"/>
+					</simpleContent>
+				</complexType>
+			</element>
+			<element name="OrderID" type="ebics:OrderIDType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Auftragsnummer für Sendeaufträge gemäß DFÜ-Abkommen.</documentation>
+					<documentation xml:lang="en">ID of the (upload) order, formatted in accordance with the document "DFÜ-Abkommen".</documentation>
+				</annotation>
+			</element>
+			<element ref="ebics:OrderParams"/>
+		</sequence>
+	</complexType>
+</schema>
diff --git a/spec/xsd/ebics_response_H005.xsd b/spec/xsd/ebics_response_H005.xsd
new file mode 100644
index 00000000..841286b7
--- /dev/null
+++ b/spec/xsd/ebics_response_H005.xsd
@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- edited with XMLSpy v2016 sp1 (x64) (http://www.altova.com) by EBICS Working Group - October 2016 -->
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:ebics="urn:org:ebics:H005" targetNamespace="urn:org:ebics:H005" elementFormDefault="qualified" attributeFormDefault="unqualified" version="1.0">
+	<annotation>
+		<documentation xml:lang="de">ebics_response_H005.xsd ist das EBICS-Protokollschema für Antwortnachrichten.</documentation>
+		<documentation xml:lang="en">ebics_response_H005.xsd is the appropriate EBICS protocol schema for standard responses.</documentation>
+	</annotation>
+	<import namespace="http://www.w3.org/2000/09/xmldsig#" schemaLocation="xmldsig-core-schema.xsd">
+		<annotation>
+			<documentation xml:lang="de">XML-Signature.</documentation>
+		</annotation>
+	</import>
+	<include schemaLocation="ebics_types_H005.xsd"/>
+	<include schemaLocation="ebics_orders_H005.xsd"/>
+	<element name="ebicsResponse">
+		<annotation>
+			<documentation xml:lang="de">Electronic Banking Internet Communication Standard des Zentralen Kreditausschusses (ZKA): Multibankfähige Schnittstelle zur internetbasierten Kommunikation.</documentation>
+			<documentation xml:lang="en">Electronic Banking Internet Communication Standard of the "Zentraler Kreditausschuss (ZKA)": multi-bank capable interface for internet-based communication.</documentation>
+		</annotation>
+		<complexType>
+			<sequence>
+				<element name="header">
+					<annotation>
+						<documentation xml:lang="de">enthält die technischen Transaktionsdaten.</documentation>
+						<documentation xml:lang="en">contains the transaction-driven data.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<element name="static" type="ebics:ResponseStaticHeaderType">
+								<annotation>
+									<documentation xml:lang="de">enhält alle festen Headereinträge.</documentation>
+									<documentation xml:lang="en">contains the static header entries.</documentation>
+								</annotation>
+							</element>
+							<element name="mutable" type="ebics:ResponseMutableHeaderType">
+								<annotation>
+									<documentation xml:lang="de">enthält alle variablen Headereinträge.</documentation>
+									<documentation xml:lang="en">contains the mutable header entries.</documentation>
+								</annotation>
+							</element>
+						</sequence>
+						<attributeGroup ref="ebics:AuthenticationMarker"/>
+					</complexType>
+				</element>
+				<element ref="ebics:AuthSignature">
+					<annotation>
+						<documentation xml:lang="de">Authentifikationssignatur.</documentation>
+						<documentation xml:lang="en">Authentication signature.</documentation>
+					</annotation>
+				</element>
+				<element name="body">
+					<annotation>
+						<documentation xml:lang="de">enthält die Auftragsdaten, EU(s) und weitere Nutzdaten.</documentation>
+						<documentation xml:lang="en">contains order data, order signature(s) and further data referring to the current order.</documentation>
+					</annotation>
+					<complexType>
+						<sequence>
+							<element name="DataTransfer" type="ebics:DataTransferResponseType" minOccurs="0">
+								<annotation>
+									<documentation xml:lang="de">Transfer von Auftragsdaten; nur bei Download anzugeben.</documentation>
+									<documentation xml:lang="en">Transfer of signature or order data; mandatory for downloads only.</documentation>
+								</annotation>
+							</element>
+							<element name="ReturnCode">
+								<annotation>
+									<documentation xml:lang="de">fachlicher Antwortcode für den vorangegangenen Request.</documentation>
+									<documentation xml:lang="en">order-related return code of the previous request.</documentation>
+								</annotation>
+								<complexType>
+									<simpleContent>
+										<extension base="ebics:ReturnCodeType">
+											<attributeGroup ref="ebics:AuthenticationMarker"/>
+										</extension>
+									</simpleContent>
+								</complexType>
+							</element>
+							<element name="TimestampBankParameter" minOccurs="0">
+								<annotation>
+									<documentation xml:lang="de">Zeitstempel der letzten Aktualisierung der Bankparameter; nur in der Initialisierungsphase anzugeben.</documentation>
+									<documentation xml:lang="en">timestamp indicating the latest update of the bank parameters; may be set during initialisation phase only.</documentation>
+								</annotation>
+								<complexType>
+									<simpleContent>
+										<extension base="ebics:TimestampType">
+											<attributeGroup ref="ebics:AuthenticationMarker"/>
+										</extension>
+									</simpleContent>
+								</complexType>
+							</element>
+						</sequence>
+					</complexType>
+				</element>
+			</sequence>
+			<attributeGroup ref="ebics:VersionAttrGroup"/>
+			<anyAttribute namespace="##targetNamespace" processContents="strict"/>
+		</complexType>
+	</element>
+	<complexType name="ResponseStaticHeaderType">
+		<annotation>
+			<documentation xml:lang="de">//TODO - Modify anotation TransactionID// Datentyp für den statischen EBICS-Header.</documentation>
+			<documentation xml:lang="en">Data type for the static EBICS header.</documentation>
+		</annotation>
+		<sequence>
+			<element name="TransactionID" type="ebics:TransactionIDType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">eindeutige, technische Transaktions-ID; wird vom Server vergeben, falls OrderAttribute entweder gleich "OZHNN" oder gleich "DZHNN" ist und falls tatsächlich eine Transaktion erzeugt wurde.</documentation>
+					<documentation xml:lang="en">unique transaction ID, provided by the server if and only if the order attribute is set to either "OZHNN" or "DZHNN" and if a transaction has been established actually.</documentation>
+				</annotation>
+			</element>
+			<element name="NumSegments" type="ebics:SegmentNumberType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Gesamtsegmentanzahl für diese Transaktion; nur bei Downloads in der Initialisierungsphase anzugeben.</documentation>
+					<documentation xml:lang="en">Total number of segments for this transaction; mandatory for downloads in initialisation phase only.</documentation>
+				</annotation>
+			</element>
+		</sequence>
+	</complexType>
+	<complexType name="ResponseMutableHeaderType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den variablen EBICS-Header.</documentation>
+			<documentation xml:lang="en">Data type for the mutable EBICS header.</documentation>
+		</annotation>
+		<sequence>
+			<element name="TransactionPhase" type="ebics:TransactionPhaseType">
+				<annotation>
+					<documentation xml:lang="de">Phase, in der sich die Transaktion gerade befindet; wird bei jedem Transaktionsschritt vom Client gesetzt und vom Server übernommen.</documentation>
+					<documentation xml:lang="en">Current phase of the transaction; this information is provided by the client for each step of the transaction, and the server adopts the setting.</documentation>
+				</annotation>
+			</element>
+			<element name="SegmentNumber" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">enthält die Nummer des aktuellen Segments, welches gerade übertragen oder angefordert wird; nur anzugeben bei TransactionPhase=Transfer und (bei Download) TransactionPhase=Initialisation.</documentation>
+					<documentation xml:lang="en">contains the number of the segment which is currently being transmitted or requested; mandatory for transaction phases 'Transfer' and (for downloads) 'Initialisation' only.</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="ebics:SegmentNumberType">
+							<attribute name="lastSegment" type="boolean" use="required">
+								<annotation>
+									<documentation xml:lang="de">Ist dies das letzte Segment der Übertragung?</documentation>
+								</annotation>
+							</attribute>
+						</extension>
+					</simpleContent>
+				</complexType>
+			</element>
+			<element name="OrderID" type="ebics:OrderIDType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Auftragsnummer von Sendeaufträgen gemäß DFÜ-Abkommen.</documentation>
+				</annotation>
+			</element>
+			<element name="ReturnCode" type="ebics:ReturnCodeType">
+				<annotation>
+					<documentation xml:lang="de">Rückmeldung des technischen Status mit einer eindeutigen Fehlernummer.</documentation>
+					<documentation xml:lang="en">Return code indicating the technical status.</documentation>
+				</annotation>
+			</element>
+			<element name="ReportText" type="ebics:ReportTextType">
+				<annotation>
+					<documentation xml:lang="de">Klartext der Rückmeldung des technischen Status.</documentation>
+					<documentation xml:lang="en">Textual interpretation of the returned technical status code.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+</schema>
diff --git a/spec/xsd/ebics_signature_S002.xsd b/spec/xsd/ebics_signature_S002.xsd
new file mode 100644
index 00000000..3127faa7
--- /dev/null
+++ b/spec/xsd/ebics_signature_S002.xsd
@@ -0,0 +1,177 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- edited with XMLSpy v2016 sp1 (x64) (http://www.altova.com) by EBICS Working Group - October 2016 -->
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:esig="http://www.ebics.org/S002" targetNamespace="http://www.ebics.org/S002" elementFormDefault="qualified" attributeFormDefault="unqualified" version="1.0">
+	<import namespace="http://www.w3.org/2000/09/xmldsig#" schemaLocation="xmldsig-core-schema.xsd"/>
+	<annotation>
+		<documentation xml:lang="de">ebics_signature enthält Typdefinitionen für elektronische Unterschriften der Versionen A005, A006 und folgende.</documentation>
+		<documentation xml:lang="en">ebics_EU contains type definitions for electronic signatures: versions A005, A006 and et sqq.</documentation>
+	</annotation>
+	<!-- Elementdefinitionen für die EU. Die XML-Klartext-Struktur wird im EBICS-Signaturdatenkontext binär interpretiert.-->
+	<element name="EBICSSignatureData" abstract="true">
+		<annotation>
+			<documentation xml:lang="de">XML-Strukturen für bankfachliche Elektronische Unterschriften (EUs).</documentation>
+			<documentation xml:lang="en">contains the digital signatures.</documentation>
+		</annotation>
+	</element>
+	<element name="UserSignatureData" type="esig:UserSignatureDataSigBookType" substitutionGroup="esig:EBICSSignatureData">
+		<annotation>
+			<documentation xml:lang="de">enthält die EUs der Teilnehmer.</documentation>
+			<documentation xml:lang="en">contains the digital signatures.</documentation>
+		</annotation>
+	</element>
+	<complexType name="UserSignatureDataSigBookType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Signaturdaten des Teilnehmers beim EU-Transfer.</documentation>
+			<documentation xml:lang="en">Data type for digital signature data transferred using EBICS.</documentation>
+		</annotation>
+		<sequence>
+			<element name="OrderSignatureData" type="esig:OrderSignatureDataType" maxOccurs="unbounded">
+				<annotation>
+					<documentation xml:lang="de">bankfachliche Elektronische Unterschrift oder Transportunterschrift (strukturiertes Format).</documentation>
+					<documentation xml:lang="en">Digital signature (either autorising an order or applied for transportation), structured format.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<simpleType name="OrderSignatureType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für kryptographische Unterschriften.</documentation>
+		</annotation>
+		<restriction base="base64Binary"/>
+	</simpleType>
+	<element name="OrderSignatureData" type="esig:OrderSignatureDataType">
+		<annotation>
+			<documentation xml:lang="de">bankfachliche Elektronische Unterschrift oder Transportunterschrift (strukturiertes Format).</documentation>
+			<documentation xml:lang="en">Digital signature (either autorising an order or applied for transportation), structured format.</documentation>
+		</annotation>
+	</element>
+	<complexType name="OrderSignatureDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für bankfachliche Elektronische Unterschrift oder Transportunterschrift (strukturiertes Format).</documentation>
+			<documentation xml:lang="en">Data type according for a digital signature (either autorising an order or applied for transportation), structured format.</documentation>
+		</annotation>
+		<sequence>
+			<element name="SignatureVersion" type="esig:SignatureVersionType">
+				<annotation>
+					<documentation xml:lang="de">Version des Signaturverfahrens.</documentation>
+					<documentation xml:lang="en">Version of the algorithm used for signature creation.</documentation>
+				</annotation>
+			</element>
+			<element name="SignatureValue" type="base64Binary">
+				<annotation>
+					<documentation xml:lang="de">Digitale Signatur.</documentation>
+					<documentation xml:lang="en">Digital signature.</documentation>
+				</annotation>
+			</element>
+			<element name="PartnerID" type="esig:PartnerIDType">
+				<annotation>
+					<documentation xml:lang="de">Kunden-ID des Unterzeichners.</documentation>
+					<documentation xml:lang="en">Customer ID of the signer.</documentation>
+				</annotation>
+			</element>
+			<element name="UserID" type="esig:UserIDType">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmer-ID.</documentation>
+					<documentation xml:lang="en">User ID.</documentation>
+				</annotation>
+			</element>
+			<element ref="ds:X509Data" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Parameter zur X.509-Funktionalität</documentation>
+					<documentation xml:lang="en">Parameter for X509Data</documentation>
+				</annotation>
+			</element>
+		</sequence>
+	</complexType>
+	<simpleType name="PartnerIDType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für eine Kunden-ID.</documentation>
+		</annotation>
+		<restriction base="token">
+			<maxLength value="35"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="UserIDType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für eine Teilnehmer-ID.</documentation>
+		</annotation>
+		<restriction base="token">
+			<maxLength value="35"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="SignatureVersionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Versionsnummern zur Elektronischen Unterschrift (EU).</documentation>
+		</annotation>
+		<restriction base="token">
+			<length value="4"/>
+			<pattern value="A\d{3}"/>
+		</restriction>
+	</simpleType>
+	<!-- Definitionen für die Uebertragung von oeffentlichen Signierschlüsseln. z.B. ueber EBICS mit INI, PUB, HCS.-->
+	<element name="SignaturePubKeyOrderData" type="esig:SignaturePubKeyOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Element für Public Key Dateien unabhängig von der Auftragsart / Geschäftsvorfall.</documentation>
+		</annotation>
+	</element>
+	<complexType name="SignaturePubKeyOrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Public Key Dateien unabhängig von der Auftragsart / Geschäftsvorfall.</documentation>
+		</annotation>
+		<sequence>
+			<element name="SignaturePubKeyInfo" type="esig:SignaturePubKeyInfoType">
+				<annotation>
+					<documentation xml:lang="de">öffentlicher Signaturschlüssel.</documentation>
+				</annotation>
+			</element>
+			<element name="PartnerID" type="esig:PartnerIDType">
+				<annotation>
+					<documentation xml:lang="de">Kunden-ID.</documentation>
+				</annotation>
+			</element>
+			<element name="UserID" type="esig:UserIDType">
+				<annotation>
+					<documentation xml:lang="de">Teilnehmer-ID.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<element name="SignaturePubKeyInfo" type="esig:SignaturePubKeyInfoType">
+		<annotation>
+			<documentation xml:lang="de">öffentlicher Signaturschlüssel.</documentation>
+		</annotation>
+	</element>
+	<complexType name="SignaturePubKeyInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für öffentliche bankfachliche Schlüssel.</documentation>
+		</annotation>
+		<complexContent>
+			<extension base="esig:PubKeyInfoType">
+				<sequence>
+					<element name="SignatureVersion" type="esig:SignatureVersionType">
+						<annotation>
+							<documentation xml:lang="de">Version des EU-Signaturverfahrens.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</extension>
+		</complexContent>
+	</complexType>
+	<complexType name="PubKeyInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Darstellung eines öffentlichen RSA-Schlüssels als Exponent-Modulus-Kombination oder als X509-Zertifikat.</documentation>
+		</annotation>
+		<sequence>
+			<element ref="ds:X509Data"/>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<simpleType name="TimestampType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Zeitstempel.</documentation>
+		</annotation>
+		<restriction base="dateTime"/>
+	</simpleType>
+</schema>
diff --git a/spec/xsd/ebics_types_H005.xsd b/spec/xsd/ebics_types_H005.xsd
new file mode 100644
index 00000000..ea13f06b
--- /dev/null
+++ b/spec/xsd/ebics_types_H005.xsd
@@ -0,0 +1,1885 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- edited with XMLSpy v2017 sp1 (x64) (http://www.altova.com) by EBICS Working Group - March 2017 -->
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:esig="http://www.ebics.org/S002" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:ebics="urn:org:ebics:H005" targetNamespace="urn:org:ebics:H005" elementFormDefault="qualified" attributeFormDefault="unqualified" version="1.0">
+	<import namespace="http://www.ebics.org/S002" schemaLocation="ebics_signature_S002.xsd"/>
+	<import namespace="http://www.w3.org/2000/09/xmldsig#" schemaLocation="xmldsig-core-schema.xsd"/>
+	<annotation>
+		<documentation xml:lang="de">ebics_types_H005.xsd enthält einfache Typdefinitionen für EBICS.</documentation>
+	</annotation>
+	<simpleType name="ProtocolVersionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für EBICS-Versionsnummern.</documentation>
+		</annotation>
+		<restriction base="token">
+			<length value="4"/>
+			<pattern value="H\d{3}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="ProtocolRevisionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für EBICS-Revisionsnummern.</documentation>
+		</annotation>
+		<restriction base="positiveInteger">
+			<maxInclusive value="99"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="EncryptionVersionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Versionsnummern zur Verschlüsselung.</documentation>
+		</annotation>
+		<restriction base="token">
+			<pattern value="E\d{3}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="SignatureVersionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Versionsnummern zur Elektronischen Unterschrift (EU).</documentation>
+		</annotation>
+		<restriction base="token">
+			<length value="4"/>
+			<pattern value="A\d{3}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="AuthenticationVersionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Versionsnummern zur Authentifikation.</documentation>
+		</annotation>
+		<restriction base="token">
+			<length value="4"/>
+			<pattern value="X\d{3}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="CryptoVersionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Versionsnummern zur Verschlüsselung, Signatur und Authentifkation.</documentation>
+		</annotation>
+		<union memberTypes="ebics:EncryptionVersionType ebics:SignatureVersionType ebics:AuthenticationVersionType"/>
+	</simpleType>
+	<simpleType name="CurrencyBaseType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Währungen (Grundtyp).</documentation>
+		</annotation>
+		<restriction base="token">
+			<length value="3"/>
+			<pattern value="[A-Z]{3}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="CurrencyCode">
+		<annotation>
+			<documentation xml:lang="de">dreistelliger Währungscode gemäß ISO 4217.</documentation>
+		</annotation>
+		<restriction base="ebics:CurrencyBaseType">
+			<length value="3"/>
+			<enumeration value="AFN">
+				<annotation>
+					<documentation xml:lang="de">Afghanistan: Afghani</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ALL">
+				<annotation>
+					<documentation xml:lang="de">Albanien: Lek</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="AMD">
+				<annotation>
+					<documentation xml:lang="de">Armenien: Dram</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ANG">
+				<annotation>
+					<documentation xml:lang="de">Niederländische Antillen: Gulden</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="AOA">
+				<annotation>
+					<documentation xml:lang="de">Angola: Kwanza</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ARS">
+				<annotation>
+					<documentation xml:lang="de">Argentinien: Peso</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="AUD">
+				<annotation>
+					<documentation xml:lang="de">Australien: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="AWG">
+				<annotation>
+					<documentation xml:lang="de">Aruba: Florin</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="AZM">
+				<annotation>
+					<documentation xml:lang="de">Aserbaidschan: Manat</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BAM">
+				<annotation>
+					<documentation xml:lang="de">Bosnien und Herzegowina: Konvertible Mark</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BBD">
+				<annotation>
+					<documentation xml:lang="de">Barbados: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BDT">
+				<annotation>
+					<documentation xml:lang="de">Bangladesch: Taka</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BGN">
+				<annotation>
+					<documentation xml:lang="de">Bulgarien: Lew</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BHD">
+				<annotation>
+					<documentation xml:lang="de">Bahrain: Dinar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BMD">
+				<annotation>
+					<documentation xml:lang="de">Bermuda: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BND">
+				<annotation>
+					<documentation xml:lang="de">Brunei: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BOB">
+				<annotation>
+					<documentation xml:lang="de">Bolivien: Boliviano</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BRL">
+				<annotation>
+					<documentation xml:lang="de">Brasilien: Real</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BSD">
+				<annotation>
+					<documentation xml:lang="de">Bahamas: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BTN">
+				<annotation>
+					<documentation xml:lang="de">Bhutan: Ngultrum</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BWP">
+				<annotation>
+					<documentation xml:lang="de">Botswana: Pula</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BYR">
+				<annotation>
+					<documentation xml:lang="de">Weißrussland (Belarus): Rubel</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="BZD">
+				<annotation>
+					<documentation xml:lang="de">Belize: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CAD">
+				<annotation>
+					<documentation xml:lang="de">Kanada: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CDF">
+				<annotation>
+					<documentation xml:lang="de">Demokratische Republik Kongo: Franc</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CHF">
+				<annotation>
+					<documentation xml:lang="de">Schweiz: Franken</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CLP">
+				<annotation>
+					<documentation xml:lang="de">Chile: Peso</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CNY">
+				<annotation>
+					<documentation xml:lang="de">China (Volksrepublik): Renminbi Yuan</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="COP">
+				<annotation>
+					<documentation xml:lang="de">Kolumbien: Peso</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CRC">
+				<annotation>
+					<documentation xml:lang="de">Costa Rica: Colón</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CSD">
+				<annotation>
+					<documentation xml:lang="de">Serbien: Dinar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CUP">
+				<annotation>
+					<documentation xml:lang="de">Kuba: Peso</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CVE">
+				<annotation>
+					<documentation xml:lang="de">Kap Verde: Escudo</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CYP">
+				<annotation>
+					<documentation xml:lang="de">Zypern (griechischer Teil): Pfund</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="CZK">
+				<annotation>
+					<documentation xml:lang="de">Tschechien: Krone</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="DJV">
+				<annotation>
+					<documentation xml:lang="de">Dschibuti: Franc</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="DKK">
+				<annotation>
+					<documentation xml:lang="de">Dänemark: Krone</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="DOP">
+				<annotation>
+					<documentation xml:lang="de">Dominikanische Republik: Peso</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="DZD">
+				<annotation>
+					<documentation xml:lang="de">Algerien: Dinar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ECS">
+				<annotation>
+					<documentation xml:lang="de">Ecuador (bis 2000): Sucre</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="EEK">
+				<annotation>
+					<documentation xml:lang="de">Estland: Krone</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="EGP">
+				<annotation>
+					<documentation xml:lang="de">Ägypten: Pfund</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ETB">
+				<annotation>
+					<documentation xml:lang="de">Äthiopien: Birr</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="EUR">
+				<annotation>
+					<documentation xml:lang="de">Europäische Währungsunion: Euro</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="FJD">
+				<annotation>
+					<documentation xml:lang="de">Fidschi: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="FKP">
+				<annotation>
+					<documentation xml:lang="de">Falklandinseln: Pfund</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="GBP">
+				<annotation>
+					<documentation xml:lang="de">Vereinigtes Königreich: Pfund</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="GEL">
+				<annotation>
+					<documentation xml:lang="de">Georgien: Lari</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="GHC">
+				<annotation>
+					<documentation xml:lang="de">Ghana: Cedi</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="GIP">
+				<annotation>
+					<documentation xml:lang="de">Gibraltar: Pfund</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="GMD">
+				<annotation>
+					<documentation xml:lang="de">Gambia: Dalasi</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="GNF">
+				<annotation>
+					<documentation xml:lang="de">Guinea: Franc</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="GTQ">
+				<annotation>
+					<documentation xml:lang="de">Guatemala: Quetzal</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="GYD">
+				<annotation>
+					<documentation xml:lang="de">Guyana: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="HKD">
+				<annotation>
+					<documentation xml:lang="de">Hongkong: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="HNL">
+				<annotation>
+					<documentation xml:lang="de">Honduras: Lempira</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="HRK">
+				<annotation>
+					<documentation xml:lang="de">Kroatien: Kuna</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="HTG">
+				<annotation>
+					<documentation xml:lang="de">Haiti: Gourde</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="HUF">
+				<annotation>
+					<documentation xml:lang="de">Ungarn: Forint</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="IDR">
+				<annotation>
+					<documentation xml:lang="de">Indonesien: Rupiah</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ILS">
+				<annotation>
+					<documentation xml:lang="de">Israel: Schekel</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="INR">
+				<annotation>
+					<documentation xml:lang="de">Indien: Rupie</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="IQD">
+				<annotation>
+					<documentation xml:lang="de">Irak: Dinar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="IRR">
+				<annotation>
+					<documentation xml:lang="de">Iran: Rial</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ISK">
+				<annotation>
+					<documentation xml:lang="de">Island: Krone</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="JMD">
+				<annotation>
+					<documentation xml:lang="de">Jamaika: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="JOD">
+				<annotation>
+					<documentation xml:lang="de">Jordanien: Dinar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="JPY">
+				<annotation>
+					<documentation xml:lang="de">Japan: Yen</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="KES">
+				<annotation>
+					<documentation xml:lang="de">Kenia: Schilling</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="KGS">
+				<annotation>
+					<documentation xml:lang="de">Kirgisistan: Som</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="KHR">
+				<annotation>
+					<documentation xml:lang="de">Kambodscha: Riel</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="KMF">
+				<annotation>
+					<documentation xml:lang="de">Komoren: Franc</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="KPW">
+				<annotation>
+					<documentation xml:lang="de">Nordkorea: Won</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="KRW">
+				<annotation>
+					<documentation xml:lang="de">Südkorea: Won</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="KWD">
+				<annotation>
+					<documentation xml:lang="de">Kuwait: Dinar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="KYD">
+				<annotation>
+					<documentation xml:lang="de">Kaimaninseln: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="KZT">
+				<annotation>
+					<documentation xml:lang="de">Kasachstan: Tenge</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="LAK">
+				<annotation>
+					<documentation xml:lang="de">Laos: Kip</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="LBP">
+				<annotation>
+					<documentation xml:lang="de">Libanon: Pfund</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="LKR">
+				<annotation>
+					<documentation xml:lang="de">Sri Lanka: Rupie</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="LRD">
+				<annotation>
+					<documentation xml:lang="de">Liberia: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="LSL">
+				<annotation>
+					<documentation xml:lang="de">Lesotho: Loti</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="LTL">
+				<annotation>
+					<documentation xml:lang="de">Litauen: Litas</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="LVL">
+				<annotation>
+					<documentation xml:lang="de">Lettland: Lats</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="LYD">
+				<annotation>
+					<documentation xml:lang="de">Libyen: Dinar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MAD">
+				<annotation>
+					<documentation xml:lang="de">Marokko: Dirham</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MDL">
+				<annotation>
+					<documentation xml:lang="de">Moldawien: Leu</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MGF">
+				<annotation>
+					<documentation xml:lang="de">Madagaskar: Franc</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MKD">
+				<annotation>
+					<documentation xml:lang="de">Mazedonien: Denar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MMK">
+				<annotation>
+					<documentation xml:lang="de">Myanmar: Kyat</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MNT">
+				<annotation>
+					<documentation xml:lang="de">Mongolei: Tugrik</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MOP">
+				<annotation>
+					<documentation xml:lang="de">Macau: Pataca</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MRO">
+				<annotation>
+					<documentation xml:lang="de">Mauretanien: Ouguiya</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MTL">
+				<annotation>
+					<documentation xml:lang="de">Malta: Lira</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MUR">
+				<annotation>
+					<documentation xml:lang="de">Mauritius: Rupie</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MVR">
+				<annotation>
+					<documentation xml:lang="de">Malediven: Rufiyaa</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MWK">
+				<annotation>
+					<documentation xml:lang="de">Malawi: Kwacha</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MXN">
+				<annotation>
+					<documentation xml:lang="de">Mexiko: Peso</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MYR">
+				<annotation>
+					<documentation xml:lang="de">Malaysia: Ringgit</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="MZM">
+				<annotation>
+					<documentation xml:lang="de">Mosambik: Metical</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="NAD">
+				<annotation>
+					<documentation xml:lang="de">Namibia: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="NGN">
+				<annotation>
+					<documentation xml:lang="de">Nigeria: Naira</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="NIO">
+				<annotation>
+					<documentation xml:lang="de">Nicaragua: Cordoba Oro</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="NOK">
+				<annotation>
+					<documentation xml:lang="de">Norwegen: Krone</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="NPR">
+				<annotation>
+					<documentation xml:lang="de">Nepal: Rupie</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="NZD">
+				<annotation>
+					<documentation xml:lang="de">Neuseeland: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="OMR">
+				<annotation>
+					<documentation xml:lang="de">Oman: Rial</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="PAB">
+				<annotation>
+					<documentation xml:lang="de">Panama: Balboa</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="PEN">
+				<annotation>
+					<documentation xml:lang="de">Peru: Nuevo Sol</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="PGK">
+				<annotation>
+					<documentation xml:lang="de">Papua-Neuguinea: Kina</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="PHP">
+				<annotation>
+					<documentation xml:lang="de">Philippinen: Peso</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="PKR">
+				<annotation>
+					<documentation xml:lang="de">Pakistan: Rupie</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="PLN">
+				<annotation>
+					<documentation xml:lang="de">Polen: Zloty</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="PYG">
+				<annotation>
+					<documentation xml:lang="de">Paraguay: Guaraní</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="QAR">
+				<annotation>
+					<documentation xml:lang="de">Katar: Riyal</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ROL">
+				<annotation>
+					<documentation xml:lang="de">Rumänien: Leu</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="RUB">
+				<annotation>
+					<documentation xml:lang="de">Russland: Rubel</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="RWF">
+				<annotation>
+					<documentation xml:lang="de">Ruanda: Franc</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SAR">
+				<annotation>
+					<documentation xml:lang="de">Saudi-Arabien: Riyal</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SBD">
+				<annotation>
+					<documentation xml:lang="de">Salomonen: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SCR">
+				<annotation>
+					<documentation xml:lang="de">Seychellen: Rupie</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SDD">
+				<annotation>
+					<documentation xml:lang="de">Sudan: Dinar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SEK">
+				<annotation>
+					<documentation xml:lang="de">Schweden: Krone</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SGD">
+				<annotation>
+					<documentation xml:lang="de">Singapur: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SHP">
+				<annotation>
+					<documentation xml:lang="de">St. Helena: Pfund</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SIT">
+				<annotation>
+					<documentation xml:lang="de">Slowenien: Tolar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SKK">
+				<annotation>
+					<documentation xml:lang="de">Slowakei: Krone</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SLL">
+				<annotation>
+					<documentation xml:lang="de">Sierra Leone: Leone</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SOS">
+				<annotation>
+					<documentation xml:lang="de">Somalia: Schilling</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SRD">
+				<annotation>
+					<documentation xml:lang="de">Suriname: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="STD">
+				<annotation>
+					<documentation xml:lang="de">São Tomé und Príncipe: Dobra</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SVC">
+				<annotation>
+					<documentation xml:lang="de">El Salvador: Colón</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SYP">
+				<annotation>
+					<documentation xml:lang="de">Syrien: Pfund</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="SZL">
+				<annotation>
+					<documentation xml:lang="de">Swasiland: Lilangeni</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="THB">
+				<annotation>
+					<documentation xml:lang="de">Thailand: Baht</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="TJS">
+				<annotation>
+					<documentation xml:lang="de">Tadschikistan: Somoni</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="TMM">
+				<annotation>
+					<documentation xml:lang="de">Turkmenistan: Manat</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="TND">
+				<annotation>
+					<documentation xml:lang="de">Tunesien: Dinar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="TOP">
+				<annotation>
+					<documentation xml:lang="de">Tonga: Pa'anga</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="TRL">
+				<annotation>
+					<documentation xml:lang="de">Türkei: Lira</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="TRY">
+				<annotation>
+					<documentation xml:lang="de">Türkei: Neue Lira (ab 2005)</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="TTD">
+				<annotation>
+					<documentation xml:lang="de">Trinidad und Tobago: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="TWD">
+				<annotation>
+					<documentation xml:lang="de">Taiwan: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="TZS">
+				<annotation>
+					<documentation xml:lang="de">Tansania: Schilling</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="UAH">
+				<annotation>
+					<documentation xml:lang="de">Ukraine: Hrywnja</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="UGX">
+				<annotation>
+					<documentation xml:lang="de">Uganda: Shilling</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="USD">
+				<annotation>
+					<documentation xml:lang="de">USA: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="UYU">
+				<annotation>
+					<documentation xml:lang="de">Uruguay: Peso</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="UZS">
+				<annotation>
+					<documentation xml:lang="de">Usbekistan: Sum</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="VEB">
+				<annotation>
+					<documentation xml:lang="de">Venezuela: Bolivar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="VND">
+				<annotation>
+					<documentation xml:lang="de">Vietnam: Dong</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="VUV">
+				<annotation>
+					<documentation xml:lang="de">Vanuatu: Vatu</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="WST">
+				<annotation>
+					<documentation xml:lang="de">Samoa: Tala</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="XAF">
+				<annotation>
+					<documentation xml:lang="de">Zentralafrikanische Wirtschafts- und Währungsunion: CFA-Franc</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="XCD">
+				<annotation>
+					<documentation xml:lang="de">Ostkaribische Währungsunion: Dollar</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="XOF">
+				<annotation>
+					<documentation xml:lang="de">Westafrikanische Wirtschafts- und Währungsunion: CFA-Franc</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="XPF">
+				<annotation>
+					<documentation xml:lang="de">Neukaledonien: CFP-Franc</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="XTS">
+				<annotation>
+					<documentation xml:lang="de">Spezialcode für Testzwecke; keine existierende Währung</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="XXX">
+				<annotation>
+					<documentation xml:lang="de">keine Währung</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="YER">
+				<annotation>
+					<documentation xml:lang="de">Jemen: Rial</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ZAR">
+				<annotation>
+					<documentation xml:lang="de">Südafrika: Rand</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ZMK">
+				<annotation>
+					<documentation xml:lang="de">Sambia: Kwacha</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="ZWD">
+				<annotation>
+					<documentation xml:lang="de">Simbabwe: Dollar</documentation>
+				</annotation>
+			</enumeration>
+		</restriction>
+	</simpleType>
+	<simpleType name="AmountValueType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für einen Betragswert (ohne Währung).</documentation>
+		</annotation>
+		<restriction base="decimal">
+			<totalDigits value="24"/>
+			<fractionDigits value="4"/>
+		</restriction>
+	</simpleType>
+	<complexType name="AmountType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für einen Betrag inkl. Währungscode-Attribut (Default = "EUR").</documentation>
+		</annotation>
+		<simpleContent>
+			<extension base="ebics:AmountValueType">
+				<attribute name="Currency" type="ebics:CurrencyBaseType" use="optional" default="EUR">
+					<annotation>
+						<documentation xml:lang="de">Währungscode, Default="EUR".</documentation>
+						<documentation xml:lang="en">Currency code, default setting is "EUR".</documentation>
+					</annotation>
+				</attribute>
+			</extension>
+		</simpleContent>
+	</complexType>
+	<simpleType name="TransactionIDType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Transaktions-ID.</documentation>
+		</annotation>
+		<restriction base="hexBinary">
+			<length value="16"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="NonceType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Nonces.</documentation>
+		</annotation>
+		<restriction base="hexBinary">
+			<length value="16"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="InstituteIDType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Instituts-ID.</documentation>
+		</annotation>
+		<restriction base="normalizedString">
+			<maxLength value="64"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="HostIDType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Host-ID.</documentation>
+		</annotation>
+		<restriction base="token">
+			<maxLength value="35"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="ProductType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Kundenprodukt-ID.</documentation>
+		</annotation>
+		<restriction base="normalizedString">
+			<maxLength value="64"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="LanguageType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für das Sprachkennzeichen des Kundenprodukts.</documentation>
+		</annotation>
+		<restriction base="language">
+			<length value="2"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="OrderTBaseType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für allgemeine Auftragsarten (Grundtyp).</documentation>
+		</annotation>
+		<restriction base="token">
+			<length value="3"/>
+			<pattern value="[A-Z0-9]{3}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="OrderIDType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für eine Auftragsnummer lt. DFÜ-Abkommen.</documentation>
+		</annotation>
+		<restriction base="token">
+			<length value="4"/>
+			<pattern value="[A-Z][A-Z0-9]{3}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="SecurityMediumType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für das Sicherheitsmedium.</documentation>
+		</annotation>
+		<restriction base="string">
+			<length value="4"/>
+			<pattern value="\d{4}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="SegmentNumberType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Segmentnummer.</documentation>
+		</annotation>
+		<restriction base="positiveInteger">
+			<totalDigits value="10"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="NumSegmentsType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Gesamtsegmentanzahl.</documentation>
+		</annotation>
+		<restriction base="nonNegativeInteger">
+			<totalDigits value="10"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="NumOrderInfosType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Gesamtanzahl der Einzelauftraginfos.</documentation>
+		</annotation>
+		<restriction base="nonNegativeInteger">
+			<totalDigits value="10"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="TransactionPhaseType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Transaktionsphase.</documentation>
+		</annotation>
+		<restriction base="token">
+			<enumeration value="Initialisation">
+				<annotation>
+					<documentation xml:lang="de">Transaktionsinitialisierung</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Transfer">
+				<annotation>
+					<documentation xml:lang="de">Auftragsdatentransfer</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Receipt">
+				<annotation>
+					<documentation xml:lang="de">Quittungstransfer</documentation>
+				</annotation>
+			</enumeration>
+		</restriction>
+	</simpleType>
+	<simpleType name="TimestampType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Zeitstempel.</documentation>
+		</annotation>
+		<restriction base="dateTime"/>
+	</simpleType>
+	<simpleType name="DateType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Datumswerte.</documentation>
+		</annotation>
+		<restriction base="date"/>
+	</simpleType>
+	<simpleType name="UserIDType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für eine Teilnehmer-ID.</documentation>
+		</annotation>
+		<restriction base="token">
+			<maxLength value="35"/>
+			<pattern value="[a-zA-Z0-9,=]{1,35}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="PartnerIDType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für eine Kunden-ID.</documentation>
+		</annotation>
+		<restriction base="token">
+			<maxLength value="35"/>
+			<pattern value="[a-zA-Z0-9,=]{1,35}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="AccountIDType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für eine Konten-ID.</documentation>
+		</annotation>
+		<restriction base="token">
+			<maxLength value="64"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="AccountNumberType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für eine Kontonummer (national/international).</documentation>
+		</annotation>
+		<restriction base="token">
+			<maxLength value="40"/>
+			<pattern value="\d{3,10}|([A-Z]{2}\d{2}[A-Za-z0-9]{3,30})"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="BankCodeType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für eine Bankleitzahl (national/international).</documentation>
+		</annotation>
+		<restriction base="token">
+			<maxLength value="11"/>
+			<pattern value="\d{8}|([A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?)"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="BankCodePrefixType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für ein nationales BLZ-Präfix.</documentation>
+		</annotation>
+		<restriction base="token">
+			<length value="2"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="NationalAccountNumberType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für eine Kontonummer (freies Format).</documentation>
+		</annotation>
+		<restriction base="normalizedString">
+			<maxLength value="40"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="NationalBankCodeType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für eine Bankleitzahl (freies Format).</documentation>
+		</annotation>
+		<restriction base="normalizedString">
+			<maxLength value="30"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="AccountHolderType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den Namen des Kontoinhabers.</documentation>
+		</annotation>
+		<restriction base="normalizedString"/>
+	</simpleType>
+	<simpleType name="AccountDescriptionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Kontobeschreibung.</documentation>
+		</annotation>
+		<restriction base="normalizedString"/>
+	</simpleType>
+	<complexType name="AccountType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Kontoinformationen.</documentation>
+		</annotation>
+		<sequence>
+			<choice maxOccurs="2">
+				<element name="AccountNumber">
+					<annotation>
+						<documentation xml:lang="de">Kontonummer (deutsches Format und/oder international als IBAN).</documentation>
+						<documentation xml:lang="en">Account number (German format and/or international=IBAN).</documentation>
+					</annotation>
+					<complexType>
+						<simpleContent>
+							<extension base="ebics:AccountNumberType">
+								<attribute name="international" type="boolean" use="optional" default="false">
+									<annotation>
+										<documentation xml:lang="de">Ist die Kontonummer im deutschen Format (international=false) oder im internationalen Format (international=true, IBAN) angegeben?</documentation>
+										<documentation xml:lang="en">Is the account number specified using the national=German or the international=IBAN format?</documentation>
+									</annotation>
+								</attribute>
+							</extension>
+						</simpleContent>
+					</complexType>
+				</element>
+				<element name="NationalAccountNumber">
+					<annotation>
+						<documentation xml:lang="de">Kontonummer im freien Format.</documentation>
+						<documentation xml:lang="en">Account in free format.</documentation>
+					</annotation>
+					<complexType>
+						<simpleContent>
+							<extension base="ebics:NationalAccountNumberType">
+								<attribute name="format" type="token" use="required">
+									<annotation>
+										<documentation xml:lang="de">Formatkennung.</documentation>
+										<documentation xml:lang="en">Format identification.</documentation>
+									</annotation>
+								</attribute>
+							</extension>
+						</simpleContent>
+					</complexType>
+				</element>
+			</choice>
+			<choice minOccurs="0" maxOccurs="2">
+				<element name="BankCode">
+					<annotation>
+						<documentation xml:lang="de">Bankleitzahl (deutsches Format und/oder international als SWIFT-BIC).</documentation>
+						<documentation xml:lang="en">Bank code (German and/or international=SWIFT-BIC).</documentation>
+					</annotation>
+					<complexType>
+						<simpleContent>
+							<extension base="ebics:BankCodeType">
+								<attribute name="international" type="boolean" use="optional" default="false">
+									<annotation>
+										<documentation xml:lang="de">Ist die Bankleitzahl im deutschen Format (international=false, BLZ) oder im internationalen Format (international=true, SWIFT-BIC) angegeben?</documentation>
+										<documentation xml:lang="en">Is the bank code specified using the national=German or the international SWIFT-BIC format?</documentation>
+									</annotation>
+								</attribute>
+								<attribute name="Prefix" type="ebics:BankCodePrefixType" use="optional">
+									<annotation>
+										<documentation xml:lang="de">nationales Präfix für Bankleitzahlen.</documentation>
+										<documentation xml:lang="en">National=German prefix for bank codes.</documentation>
+									</annotation>
+								</attribute>
+							</extension>
+						</simpleContent>
+					</complexType>
+				</element>
+				<element name="NationalBankCode">
+					<annotation>
+						<documentation xml:lang="de">Bankleitzahl im freien Format.</documentation>
+						<documentation xml:lang="en">Bank code in free format.</documentation>
+					</annotation>
+					<complexType>
+						<simpleContent>
+							<extension base="ebics:NationalBankCodeType">
+								<attribute name="format" type="token" use="required">
+									<annotation>
+										<documentation xml:lang="de">Formatkennung.</documentation>
+										<documentation xml:lang="en">Format identification.</documentation>
+									</annotation>
+								</attribute>
+							</extension>
+						</simpleContent>
+					</complexType>
+				</element>
+			</choice>
+			<element name="AccountHolder" type="ebics:AccountHolderType" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Name des Kontoinhabers.</documentation>
+					<documentation xml:lang="de">Name of the account holder.</documentation>
+				</annotation>
+			</element>
+		</sequence>
+		<attribute name="Currency" type="ebics:CurrencyBaseType" use="optional" default="EUR">
+			<annotation>
+				<documentation xml:lang="de">Währungscode für dieses Konto, Default=EUR.</documentation>
+				<documentation xml:lang="en">Currency code for this account, Default=EUR.</documentation>
+			</annotation>
+		</attribute>
+		<attribute name="Description" type="ebics:AccountDescriptionType" use="optional">
+			<annotation>
+				<documentation xml:lang="de">Kontobeschreibung.</documentation>
+				<documentation xml:lang="en">Description of this account.</documentation>
+			</annotation>
+		</attribute>
+	</complexType>
+	<simpleType name="AccountNumberRoleType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Rolle eines Zahlungsverkehrskontos innerhalb einer Transaktion.</documentation>
+		</annotation>
+		<restriction base="token">
+			<enumeration value="Originator">
+				<annotation>
+					<documentation xml:lang="de">Auftraggeberkonto</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Recipient">
+				<annotation>
+					<documentation xml:lang="de">Empfängerkonto</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Charges">
+				<annotation>
+					<documentation xml:lang="de">Gebührenkonto</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Other">
+				<annotation>
+					<documentation xml:lang="de">andere Kontorolle</documentation>
+				</annotation>
+			</enumeration>
+		</restriction>
+	</simpleType>
+	<simpleType name="BankCodeRoleType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Rolle eines Kreditinstituts innerhalb einer Transaktion (repräsentiert durch die Bankleitzahl).</documentation>
+		</annotation>
+		<restriction base="token">
+			<enumeration value="Originator">
+				<annotation>
+					<documentation xml:lang="de">Auftraggeberbank</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Recipient">
+				<annotation>
+					<documentation xml:lang="de">Empfängerbank</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Correspondent">
+				<annotation>
+					<documentation xml:lang="de">Korrespondenzbank</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Other">
+				<annotation>
+					<documentation xml:lang="de">andere Bankrolle</documentation>
+				</annotation>
+			</enumeration>
+		</restriction>
+	</simpleType>
+	<simpleType name="AccountHolderRoleType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Rolle eines Kontoinhabers innerhalb einer Transaktion.</documentation>
+		</annotation>
+		<restriction base="token">
+			<enumeration value="Originator">
+				<annotation>
+					<documentation xml:lang="de">Auftraggeber</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Recipient">
+				<annotation>
+					<documentation xml:lang="de">Empfänger</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Presenter">
+				<annotation>
+					<documentation xml:lang="de">Überbringer, Einreicher</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="Other">
+				<annotation>
+					<documentation xml:lang="de">andere Rolle</documentation>
+				</annotation>
+			</enumeration>
+		</restriction>
+	</simpleType>
+	<complexType name="AttributedAccountType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Kontoinformationen inkl. der Eigenschaftszuordnung innerhalb einer Zahlungstransaktion.</documentation>
+		</annotation>
+		<sequence>
+			<choice maxOccurs="2">
+				<element name="AccountNumber">
+					<annotation>
+						<documentation xml:lang="de">Kontonummer (deutsches Format oder international als IBAN).</documentation>
+						<documentation xml:lang="en">Kontonummer (Account number (German format and/or international = IBAN).</documentation>
+					</annotation>
+					<complexType>
+						<simpleContent>
+							<extension base="ebics:AccountNumberType">
+								<attribute name="Role" type="ebics:AccountNumberRoleType" use="required">
+									<annotation>
+										<documentation xml:lang="de">Rolle des Kontos innerhalb der Zahlungstransaktion.</documentation>
+										<documentation xml:lang="en">Role of the account during the transaction.</documentation>
+									</annotation>
+								</attribute>
+								<attribute name="Description" type="normalizedString">
+									<annotation>
+										<documentation xml:lang="de">Textuelle Beschreibung der Funktion, falls role=Other ausgewählt wird.</documentation>
+										<documentation xml:lang="en">Textual description of the role the account place during the transaction; use only if the corresponding 'role' field is set to 'other'.</documentation>
+									</annotation>
+								</attribute>
+								<attribute name="international" type="boolean" use="optional" default="false">
+									<annotation>
+										<documentation xml:lang="de">Ist die Kontonummer im deutschen Format (international=false) oder im internationalen Format (international=true, IBAN) angegeben?</documentation>
+										<documentation xml:lang="en">Is the account number specified using the national=German or the international=IBAN format?</documentation>
+									</annotation>
+								</attribute>
+							</extension>
+						</simpleContent>
+					</complexType>
+				</element>
+				<element name="NationalAccountNumber">
+					<annotation>
+						<documentation xml:lang="de">Kontonummer im freien Format.</documentation>
+						<documentation xml:lang="en">Account in free format.</documentation>
+					</annotation>
+					<complexType>
+						<simpleContent>
+							<extension base="ebics:NationalAccountNumberType">
+								<attribute name="Role" type="ebics:AccountNumberRoleType" use="required">
+									<annotation>
+										<documentation xml:lang="de">Rolle des Kontos innerhalb der Zahlungstransaktion.</documentation>
+										<documentation xml:lang="en">Role of the account during the transaction.</documentation>
+									</annotation>
+								</attribute>
+								<attribute name="Description" type="normalizedString">
+									<annotation>
+										<documentation xml:lang="de">Textuelle Beschreibung der Funktion, falls role=Other ausgewählt wird.</documentation>
+										<documentation xml:lang="en">Textual description of the role the account place during the transaction; use only if the corresponding 'role' field is set to 'other'.</documentation>
+									</annotation>
+								</attribute>
+								<attribute name="format" type="token" use="required">
+									<annotation>
+										<documentation xml:lang="de">Formatkennung.</documentation>
+										<documentation xml:lang="en">Format identification.</documentation>
+									</annotation>
+								</attribute>
+							</extension>
+						</simpleContent>
+					</complexType>
+				</element>
+			</choice>
+			<choice minOccurs="0" maxOccurs="2">
+				<element name="BankCode">
+					<annotation>
+						<documentation xml:lang="de">Bankleitzahl (deutsches Format oder international als SWIFT-BIC).</documentation>
+						<documentation xml:lang="en">Bank code (German and/or international=SWIFT-BIC).</documentation>
+					</annotation>
+					<complexType>
+						<simpleContent>
+							<extension base="ebics:BankCodeType">
+								<attribute name="Role" type="ebics:BankCodeRoleType" use="required">
+									<annotation>
+										<documentation xml:lang="de">Rolle des kontoführenden Instituts innerhalb der Zahlungstransaktion.</documentation>
+										<documentation xml:lang="en">Role of the bank during the transaction.</documentation>
+									</annotation>
+								</attribute>
+								<attribute name="Description" type="normalizedString">
+									<annotation>
+										<documentation xml:lang="de">Textuelle Beschreibung der Funktion, falls role=Other ausgewählt wird.</documentation>
+										<documentation xml:lang="en">Textual description of the role the account place during the transaction; use only if the corresponding 'role' field is set to 'other'.</documentation>
+									</annotation>
+								</attribute>
+								<attribute name="international" type="boolean" use="optional" default="false">
+									<annotation>
+										<documentation xml:lang="de">Ist die Bankleitzahl im deutschen Format (international=false, BLZ) oder im internationalen Format (international=true, SWIFT-BIC) angegeben?</documentation>
+										<documentation xml:lang="en">Is the bank code specified using the national=German or the international=SWIFT-BIC format?</documentation>
+									</annotation>
+								</attribute>
+								<attribute name="Prefix" type="ebics:BankCodePrefixType" use="optional">
+									<annotation>
+										<documentation xml:lang="de">nationales Präfix für Bankleitzahlen.</documentation>
+										<documentation xml:lang="en">National=German prefix for bank codes.</documentation>
+									</annotation>
+								</attribute>
+							</extension>
+						</simpleContent>
+					</complexType>
+				</element>
+				<element name="NationalBankCode">
+					<annotation>
+						<documentation xml:lang="de">Bankleitzahl im freien Format.</documentation>
+						<documentation xml:lang="en">Bank code in free format.</documentation>
+					</annotation>
+					<complexType>
+						<simpleContent>
+							<extension base="ebics:NationalBankCodeType">
+								<attribute name="Role" type="ebics:BankCodeRoleType" use="required">
+									<annotation>
+										<documentation xml:lang="de">Rolle des kontoführenden Instituts innerhalb der Zahlungstransaktion.</documentation>
+										<documentation xml:lang="en">Role of the bank during the transaction.</documentation>
+									</annotation>
+								</attribute>
+								<attribute name="Description" type="normalizedString">
+									<annotation>
+										<documentation xml:lang="de">Textuelle Beschreibung der Funktion, falls role=Other ausgewählt wird.</documentation>
+										<documentation xml:lang="en">Textual description of the role the account place during the transaction; use only if the corresponding 'role' field is set to 'other'.</documentation>
+									</annotation>
+								</attribute>
+								<attribute name="format" type="token" use="required">
+									<annotation>
+										<documentation xml:lang="de">Formatkennung.</documentation>
+										<documentation xml:lang="en">Format identification.</documentation>
+									</annotation>
+								</attribute>
+							</extension>
+						</simpleContent>
+					</complexType>
+				</element>
+			</choice>
+			<element name="AccountHolder" minOccurs="0">
+				<annotation>
+					<documentation xml:lang="de">Name des Kontoinhabers.</documentation>
+					<documentation xml:lang="de">Name of the account holder.</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="ebics:AccountHolderType">
+							<attribute name="Role" type="ebics:AccountHolderRoleType" use="required">
+								<annotation>
+									<documentation xml:lang="de">Rolle des Kontoinhabers innerhalb der Zahlungstransaktion.</documentation>
+									<documentation xml:lang="en">Role of the account holder during the transaction.</documentation>
+								</annotation>
+							</attribute>
+							<attribute name="Description" type="normalizedString">
+								<annotation>
+									<documentation xml:lang="de">Textuelle Beschreibung der Rolle, falls role=Other ausgewählt wird.</documentation>
+									<documentation xml:lang="en">Textual description of the role the account holder place during the transaction; use only if the corresponding 'role' field is set to 'other'.</documentation>
+								</annotation>
+							</attribute>
+						</extension>
+					</simpleContent>
+				</complexType>
+			</element>
+		</sequence>
+		<attribute name="Currency" type="ebics:CurrencyBaseType" use="optional" default="EUR">
+			<annotation>
+				<documentation xml:lang="de">Währungscode für dieses Konto, Default=EUR.</documentation>
+				<documentation xml:lang="en">Currency code for this account, Default=EUR.</documentation>
+			</annotation>
+		</attribute>
+		<attribute name="Description" type="ebics:AccountDescriptionType">
+			<annotation>
+				<documentation xml:lang="de">Kontobeschreibung.</documentation>
+				<documentation xml:lang="en">Description of this account.</documentation>
+			</annotation>
+		</attribute>
+	</complexType>
+	<simpleType name="SignatureDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für binäre Signaturdaten (komprimiert, verschlüsselt und kodiert).</documentation>
+		</annotation>
+		<restriction base="base64Binary"/>
+	</simpleType>
+	<simpleType name="OrderDataType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für binäre Auftragsdaten (komprimiert, verschlüsselt und kodiert).</documentation>
+		</annotation>
+		<restriction base="base64Binary"/>
+	</simpleType>
+	<simpleType name="AuthorisationLevelType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Berechtigungsklassen zur Elektronischen Unterschrift.</documentation>
+		</annotation>
+		<restriction base="token">
+			<length value="1"/>
+			<enumeration value="E">
+				<annotation>
+					<documentation xml:lang="de">Einzelunterschrift</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="A">
+				<annotation>
+					<documentation xml:lang="de">Erstunterschrift</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="B">
+				<annotation>
+					<documentation xml:lang="de">Zweitunterschrift</documentation>
+				</annotation>
+			</enumeration>
+			<enumeration value="T">
+				<annotation>
+					<documentation xml:lang="de">Transportunterschrift</documentation>
+				</annotation>
+			</enumeration>
+		</restriction>
+	</simpleType>
+	<simpleType name="AuthorisationLevelListType">
+		<annotation>
+			<documentation xml:lang="de">Listentyp für Berechtigungsklassen zur Elektronischen Unterschrift.</documentation>
+		</annotation>
+		<list itemType="ebics:AuthorisationLevelType"/>
+	</simpleType>
+	<simpleType name="DigestAlgorithmType">
+		<annotation>
+			<documentation>Datentyp für Hashfunktionen.</documentation>
+		</annotation>
+		<restriction base="anyURI"/>
+	</simpleType>
+	<simpleType name="DigestType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Hashwerte.</documentation>
+		</annotation>
+		<restriction base="ds:DigestValueType"/>
+	</simpleType>
+	<complexType name="DataDigestType">
+		<simpleContent>
+			<extension base="ebics:DigestType">
+				<attribute name="SignatureVersion" type="ebics:SignatureVersionType" use="required">
+					<annotation>
+						<documentation xml:lang="de">Version des Signaturverfahrens.</documentation>
+						<documentation xml:lang="en">Version of the algorithm used for signature creation.</documentation>
+					</annotation>
+				</attribute>
+			</extension>
+		</simpleContent>
+	</complexType>
+	<simpleType name="SignatureType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für kryptographische Unterschriften.</documentation>
+		</annotation>
+		<restriction base="base64Binary"/>
+	</simpleType>
+	<simpleType name="SymmetricKeyType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für symmetrische Schlüssel.</documentation>
+		</annotation>
+		<restriction base="base64Binary"/>
+	</simpleType>
+	<complexType name="PubKeyDigestType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Hashwerte und Attribute von öffentlichen Schlüsseln.</documentation>
+		</annotation>
+		<simpleContent>
+			<extension base="ebics:DigestType">
+				<attribute name="Algorithm" type="anyURI" use="required">
+					<annotation>
+						<documentation xml:lang="de">Hashalgorithmus.</documentation>
+						<documentation xml:lang="en">Name of the used hash algorithm.</documentation>
+					</annotation>
+				</attribute>
+			</extension>
+		</simpleContent>
+	</complexType>
+	<complexType name="PubKeyInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Darstellung eines öffentlichen RSA-Schlüssels als Exponent-Modulus-Kombination oder als X509-Zertifikat.</documentation>
+		</annotation>
+		<sequence>
+			<element ref="ds:X509Data"/>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<complexType name="EncryptionPubKeyInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für öffentliche Verschlüsselungsschlüssel.</documentation>
+		</annotation>
+		<complexContent>
+			<extension base="ebics:PubKeyInfoType">
+				<sequence>
+					<element name="EncryptionVersion" type="ebics:EncryptionVersionType">
+						<annotation>
+							<documentation xml:lang="de">Version des Verschlüsselungsverfahrens.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</extension>
+		</complexContent>
+	</complexType>
+	<complexType name="AuthenticationPubKeyInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für öffentlichen Authentfikationsschlüssel.</documentation>
+		</annotation>
+		<complexContent>
+			<extension base="ebics:PubKeyInfoType">
+				<sequence>
+					<element name="AuthenticationVersion" type="ebics:AuthenticationVersionType">
+						<annotation>
+							<documentation xml:lang="de">Version des Authentifikationsverfahrens.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</extension>
+		</complexContent>
+	</complexType>
+	<complexType name="SignatureCertificateInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für öffentliche bankfachliche Schlüssel.</documentation>
+			<documentation xml:lang="en">Data type for public authorisation (ES) key.</documentation>
+		</annotation>
+		<complexContent>
+			<extension base="ebics:CertificateInfoType">
+				<sequence>
+					<element name="SignatureVersion" type="ebics:SignatureVersionType">
+						<annotation>
+							<documentation xml:lang="de">Version des EU-Signaturverfahrens.</documentation>
+							<documentation xml:lang="en">ES-Version.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</extension>
+		</complexContent>
+	</complexType>
+	<complexType name="AuthenticationCertificateInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für öffentlichen Schlüssel zur Authentisierung.</documentation>
+			<documentation xml:lang="en">Data type for public for identification and authentication.</documentation>
+		</annotation>
+		<complexContent>
+			<extension base="ebics:CertificateInfoType">
+				<sequence>
+					<element name="AuthenticationVersion" type="ebics:AuthenticationVersionType">
+						<annotation>
+							<documentation xml:lang="de">Version des Authentifikationsverfahrens.</documentation>
+							<documentation xml:lang="de">Authentication version.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</extension>
+		</complexContent>
+	</complexType>
+	<complexType name="EncryptionCertificateInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für öffentlichen Verschlüsselungsschlüssel.</documentation>
+			<documentation xml:lang="en">Data type for encryption key.</documentation>
+		</annotation>
+		<complexContent>
+			<extension base="ebics:CertificateInfoType">
+				<sequence>
+					<element name="EncryptionVersion" type="ebics:EncryptionVersionType">
+						<annotation>
+							<documentation xml:lang="de">Version des Verschlüsselungsverfahrens.</documentation>
+							<documentation xml:lang="en">Encryption Version.</documentation>
+						</annotation>
+					</element>
+				</sequence>
+			</extension>
+		</complexContent>
+	</complexType>
+	<complexType name="CertificateInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Zertifikate hinsichtlich der "bank-technical signature for authorisation" (ES).</documentation>
+			<documentation xml:lang="en">Data Type for Certificates for the bank-technical signature for authorisation (ES)</documentation>
+		</annotation>
+		<sequence>
+			<element ref="ds:X509Data"/>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<simpleType name="ReturnCodeType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Antwortcodes.</documentation>
+		</annotation>
+		<restriction base="token">
+			<length value="6"/>
+			<pattern value="\d{6}"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="ReportTextType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den Erklärungstext zum Antwortcode.</documentation>
+		</annotation>
+		<restriction base="normalizedString">
+			<maxLength value="256"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="ReceiptCodeType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Quittierungscodes.</documentation>
+		</annotation>
+		<restriction base="nonNegativeInteger">
+			<maxInclusive value="1"/>
+			<minInclusive value="0"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="NameType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für Kunden-, Teilnehmer-, Straßen- oder Ortsnamen.</documentation>
+		</annotation>
+		<restriction base="normalizedString"/>
+	</simpleType>
+	<simpleType name="OrderDescriptionType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Beschreibung von Auftragsarten.</documentation>
+		</annotation>
+		<restriction base="normalizedString">
+			<maxLength value="128"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="UserStatusType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für den Teilnehmerstatus.</documentation>
+		</annotation>
+		<restriction base="nonNegativeInteger">
+			<maxInclusive value="99"/>
+		</restriction>
+	</simpleType>
+	<element name="Parameter">
+		<annotation>
+			<documentation xml:lang="de">generic parameter</documentation>
+			<documentation xml:lang="en">Generic key value parameters.</documentation>
+		</annotation>
+		<complexType>
+			<sequence>
+				<element name="Name" type="token">
+					<annotation>
+						<documentation xml:lang="de">name of parameter</documentation>
+						<documentation xml:lang="en">Name of the parameter (= key).</documentation>
+					</annotation>
+				</element>
+				<element name="Value">
+					<annotation>
+						<documentation xml:lang="de">value of parameter</documentation>
+						<documentation xml:lang="en">Value of the parameter.</documentation>
+					</annotation>
+					<complexType>
+						<simpleContent>
+							<extension base="anySimpleType">
+								<attribute name="Type" type="NCName" use="required">
+									<annotation>
+										<documentation xml:lang="de">XML-Typ des Parameterwerts (Vorschlag für default ist string).</documentation>
+										<documentation xml:lang="en">XML type of the parameter value (Proposal for default is string).</documentation>
+									</annotation>
+								</attribute>
+							</extension>
+						</simpleContent>
+					</complexType>
+				</element>
+			</sequence>
+		</complexType>
+	</element>
+	<complexType name="DataEncryptionInfoType">
+		<annotation>
+			<documentation xml:lang="de">Datentyp für die Darstellung von Information zur Verschlüsselung der Auftragsdaten.</documentation>
+			<documentation xml:lang="en">Data type for the modelling of information regarding the encryption of signature and order data.</documentation>
+		</annotation>
+		<sequence>
+			<element name="EncryptionPubKeyDigest">
+				<annotation>
+					<documentation xml:lang="de">Hashwert des öffentlichen Verschlüsselungsschlüssels des Empfängers der verschlüsselten Auftragsdaten.</documentation>
+					<documentation xml:lang="en">Hash value of the public encryption key owned by the receipient of the encrypted order data.</documentation>
+				</annotation>
+				<complexType>
+					<simpleContent>
+						<extension base="ebics:PubKeyDigestType">
+							<attribute name="Version" type="ebics:EncryptionVersionType" use="required">
+								<annotation>
+									<documentation xml:lang="de">Version des Verschlüsselungsverfahrens.</documentation>
+									<documentation xml:lang="en">Version of the encryption method.</documentation>
+								</annotation>
+							</attribute>
+						</extension>
+					</simpleContent>
+				</complexType>
+			</element>
+			<element name="TransactionKey" type="ebics:SymmetricKeyType">
+				<annotation>
+					<documentation xml:lang="de">Asymmetrisch verschlüsselter symmetrischer Transaktionsschlüssel.</documentation>
+					<documentation xml:lang="en">The asymmetrically encrypted symmetric transaction key.</documentation>
+				</annotation>
+			</element>
+			<any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+		</sequence>
+	</complexType>
+	<element name="AuthSignature" type="ds:SignatureType">
+		<annotation>
+			<documentation xml:lang="de">Authentifikationssignatur.</documentation>
+			<documentation xml:lang="en">Authentication signature.</documentation>
+		</annotation>
+	</element>
+	<simpleType name="String255Type">
+		<annotation>
+			<documentation xml:lang="de">String up to 255 characters.</documentation>
+		</annotation>
+		<restriction base="normalizedString">
+			<maxLength value="255"/>
+		</restriction>
+	</simpleType>
+	<!--Following types are BTF required type definitions-->
+	<simpleType name="CodeStringType">
+		<restriction base="string">
+			<minLength value="1"/>
+			<maxLength value="10"/>
+			<pattern value="[A-Z0-9]*"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="NumStringType">
+		<annotation>
+			<documentation>Type is used for ISO variant and version</documentation>
+		</annotation>
+		<restriction base="string">
+			<minLength value="2"/>
+			<maxLength value="3"/>
+			<pattern value="[0-9]*"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="FileNameStringType">
+		<annotation>
+			<documentation>Type ist used for original file name</documentation>
+		</annotation>
+		<restriction base="string">
+			<minLength value="1"/>
+			<maxLength value="256"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="MessageNameStringType">
+		<annotation>
+			<documentation>Type ist used for name or rather kind of Message</documentation>
+		</annotation>
+		<restriction base="token">
+			<minLength value="1"/>
+			<maxLength value="10"/>
+			<pattern value="[a-z\.0-9]*"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="ServiceNameStringType">
+		<annotation>
+			<documentation>Service Code name: External list specified and maintained by EBICS. Basis is the "SWIFT-list" for the field "description" (SCT, DCT, XCT, SDD, DDD, STM, REP...) plus additional codes needed for further services </documentation>
+		</annotation>
+		<restriction base="ebics:CodeStringType">
+			<maxLength value="3"/>
+			<minLength value="3"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="ScopeStringType">
+		<restriction base="ebics:CodeStringType">
+			<maxLength value="3"/>
+			<minLength value="2"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="ServiceOptionStringType">
+		<restriction base="ebics:CodeStringType">
+			<minLength value="3"/>
+		</restriction>
+	</simpleType>
+	<simpleType name="ContainerStringType">
+		<restriction base="ebics:CodeStringType">
+			<maxLength value="3"/>
+			<minLength value="3"/>
+			<enumeration value="SVC"/>
+			<enumeration value="XML"/>
+			<enumeration value="ZIP"/>
+		</restriction>
+	</simpleType>
+</schema>