<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

	<!-- Elements -->

	<xs:element name="company-information">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="company-information"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="company-message">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="company-message"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="clients">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="clients"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-agreements">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-agreements"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-agreement">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-agreement"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-delivery-types">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="client-delivery-type" minOccurs="0" maxOccurs="unbounded">
					<xs:complexType>
						<xs:sequence>

							<!-- The name of the delivery type. To use when specifying one for clients and client invoices -->
							<xs:element name="name" type="xs:string"/>

							<!--
												 True if this is the default delivery type that will be used for clients and client invoices
												 if none is specified.
												 -->
							<xs:element name="default" type="xs:boolean"/>

						</xs:sequence>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="company">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="company"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-month-report-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-month-report-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-month-report-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-month-report-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-month-report-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-month-report-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-article-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-article-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-run-create">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-run-create"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-runs">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-runs"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-user-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-user-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-user-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-user-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-user-writable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-user-writable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-schedules-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-schedules-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-schedule-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-schedule-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-rolling-schedule-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-rolling-schedule-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-fixed-schedule-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-fixed-schedule-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-user-schedule-metadatas">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-user-schedule-metadatas"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="bank-accounts">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="bank-accounts"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="bank-transactions">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="bank-transactions"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="budgets">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="budgets"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="budget-accounts">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="budget-accounts"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="products">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="products"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="product">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="product"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="projects">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="projects"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="dimensions">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="dimensions"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="dimension-entries">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="dimension-entries"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="dimension-entry-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="dimension-entry-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="project">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="project"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="projects-metadata">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="projects-metadata"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="suppliers">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="suppliers"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="supplier">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="supplier"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="subcontractor-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="subcontractor-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="subcontractor-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="subcontractor-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="subcontractor-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="subcontractor-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-invoices">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="paged-result">
					<xs:sequence>
						<xs:element name="client-invoice" type="client-invoice" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-invoice">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-invoice"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-invoice-payment-writable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-invoice-payment-writable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="supplier-invoices">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="paged-result">
					<xs:sequence>
						<xs:element name="supplier-invoice" type="supplier-invoice" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="supplier-invoice">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="supplier-invoice"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="supplier-invoice-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="supplier-invoice-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="supplier-invoice-approval">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="supplier-invoice-approval"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="supplier-invoice-bundle-create-result">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="nr" type="xs:int"/>
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="users">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="users"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="user">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="user"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="accesses">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="accesses"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="access">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="access"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="access-roles">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="access-roles"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-event">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-event"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-child">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-child"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-events">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-events"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-invoice-templates">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-invoice-templates"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-invoice-template">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-invoice-template"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="accounting-year-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="accounting-year-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="accounting-year-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="accounting-year-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="accounting-year-restriction-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="accounting-year-restriction-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="accounting-year-restriction-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="accounting-year-restriction-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="voucher-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="voucher-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="vouchers-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="vouchers-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="voucher-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="voucher-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="update-client-agreement">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="client-agreement" type="client-agreement"/>
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="update-client-agreement-result">
		<xs:complexType>
			<xs:sequence>
				<!-- The revision nr of the created revision -->
				<xs:element name="revision-nr" type="xs:int"/>
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="exchange-rate">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="from-currency" type="xs:string"/>
				<xs:element name="to-currency" type="xs:string"/>
				<xs:element name="rate" type="xs:decimal"/>
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="account-metadata">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="account-metadata"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="account-metadatas">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="account-metadatas"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="activity-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="activity-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="activity-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="activity-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="internal-hourly-cost-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="internal-hourly-cost-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="internal-hourly-cost-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="internal-hourly-cost-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="internal-hourly-cost-writable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="internal-hourly-cost-writable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="internal-hourly-cost-writables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="internal-hourly-cost-writables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="event-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="event-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="event-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="event-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="event-writable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="event-writable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="certify-events-request">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="certify-events-request"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="approve-events-request">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="approve-events-request"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="unlock-events-request">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="unlock-events-request"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="event-restriction-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="event-restriction-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="event-restriction-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="event-restriction-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-project-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-project-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-project-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-project-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-project-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-project-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-project-readable-v2">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-project-readable-v2"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-project-readables-v2">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-project-readables-v2"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-project-activities-v2-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-project-activities-v2-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-project-users-v2-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-project-users-v2-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-project-prices-writeable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-project-prices-writeable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="user-authentication">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="user-authentication"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="tokens">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="tokens"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="token">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="token"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="accessible-companies">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="accessible-companies"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="expense-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="expense-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="expense-file-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="expense-file-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="company-card-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="company-card-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="expense-entry-form">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="expense-entry-form"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="expense-entry-form-defaults">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="expense-entry-form-defaults"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="expense-entry-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="expense-entry-readables"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="expense-entry-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="expense-entry-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="car-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="car-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="expense-entry-writable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="expense-entry-writable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="card-transactions">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="card-transactions"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="expense-writable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="expense-writable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="translations">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="translations"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="vouchers-detailed">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="paged-result">
					<xs:sequence>
						<xs:element name="voucher" type="voucher-detailed" minOccurs="0"
									maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="revenue-ledgers">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="paged-result">
					<xs:sequence>
						<xs:element name="revenue-ledger" type="revenue-ledger" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="revenues">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="paged-result">
					<xs:sequence>
						<xs:element name="revenue" type="revenue" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="revenue">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="revenue"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="revenue-create">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="revenue-create"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="revenue-update">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="revenue-update"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="created">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="id" type="xs:int"/>
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="saved">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="id" type="xs:int" minOccurs="0"/>
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="deleted">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="id" type="xs:int" minOccurs="0"/>
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="error">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="message" type="xs:string"/>
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="ok">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="id" type="xs:int"/>
				<xs:element name="message" type="xs:string" minOccurs="0"/>
				<xs:element name="uncertified-client-project-id" type="xs:int" minOccurs="0" maxOccurs="unbounded"/>
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="report">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="report"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="bank-information-validate-request">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="bank-information-validate-request"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="bank-information-validate-result">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="bank-information-validate-result"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="bank-transaction-consolidate-revenues">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="bank-transaction-consolidate-revenues"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="revenue-fuzzy-consolidation">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="revenue-fuzzy-consolidation"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="revenue-fuzzy-consolidation-result">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="revenue-fuzzy-consolidation-result"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="create-bank-transaction">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="create-bank-transaction"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="bank-transaction">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="bank-transaction"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="bank-transaction-distributions">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="bank-transaction-distributions"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-run-pay">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-run-pay"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-run-bookkeep">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-run-bookkeep"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="payroll-transactions">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="payroll-transactions"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="create-foundation-grant">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="create-foundation-grant"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="foundation-grant">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="foundation-grant-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="foundation-grant-update">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="foundation-grant-update"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="foundation-grant-return">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="foundation-grant-return"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="foundation-grants">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="paged-result">
					<xs:sequence>
						<xs:element name="foundation-grant" type="foundation-grant-readable" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="create-foundation-grant-payment">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="create-foundation-grant-payment"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="update-foundation-grant-payment">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="update-foundation-grant-payment"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="create-foundation-grant-repayment">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="create-foundation-grant-repayment"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="foundation-grant-payment">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="foundation-grant-payment-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="foundation-grant-payments">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="paged-result">
					<xs:sequence>
						<xs:element name="foundation-grant-payment" type="foundation-grant-payment-readable" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="foundation-grant-repayment">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="foundation-grant-repayment-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="foundation-grant-repayments">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="paged-result">
					<xs:sequence>
						<xs:element name="foundation-grant-repayment" type="foundation-grant-repayment-readable" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="sub-foundation-readable">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="sub-foundation-readable"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="sub-foundations-readables">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="paged-result">
					<xs:sequence>
						<xs:element name="sub-foundation-readable" type="sub-foundation-readable" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="eurocard-files-request">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="eurocard-files-request"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<!-- Types -->

	<xs:complexType name="translations">
		<xs:sequence>
			<xs:element name="translation" maxOccurs="unbounded">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="name" type="xs:string"/>
						<xs:element name="value" type="xs:string"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-writable">
		<xs:sequence>
			<xs:element name="expense-entries">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="expense-entry" maxOccurs="unbounded"
									type="expense-entry-reference"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-entry-writable">
		<xs:sequence>
			<xs:element name="expense-file" type="expense-file-reference"/>
			<xs:element name="company-card" type="company-card-reference" minOccurs="0"/>
			<xs:element name="expense-type" type="expense-type-reference"/>
			<xs:element name="persons" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="digital" type="xs:boolean"/>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="vat" type="xs:long"/>
			<xs:element name="currency-type" type="xs:string"/>
			<xs:element name="country-code" type="xs:string"/>
			<xs:element name="dimension-entries">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="dimension-entry" type="dimension-entry-reference" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="re-invoicing" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="client-project" type="client-project-reference"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="card-transaction" type="card-transaction-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Optional. Set it to file this receipt against a card purchase returned by
						card-transactions. Only settable when the entry is created; an update may repeat the
						key the entry already carries, but cannot add, change or remove the link.

						The purchase must be one of the caller's own open, confirmed purchases, i.e. one that
						card-transactions returned. A key naming anything else is rejected.

						When the purchase has a company-card, file the entry with that card and with the
						amount the card was charged: copy billing-amount into amount and
						billing-currency-type into currency-type. The purchase amount and currency are not
						accepted for a purchase made in another currency.

						VAT follows the entry's own country-code, which normally comes from the purchase.
						When it differs from the company's country, send vat as 0: no VAT may be claimed on a
						receipt from another country, and an entry that carries any is rejected with a
						conflict. Unlike the company card and the amount, the country is not checked against
						the purchase, so a receipt that genuinely belongs to another country than the card
						issuer reports can be filed as such.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="card-transactions">
		<xs:complexContent>
			<xs:extension base="paged-result">
				<xs:sequence>
					<xs:element name="card-transaction" type="card-transaction" minOccurs="0" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="card-transaction">
		<xs:sequence>
			<xs:element name="key" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						Stable identifier of the card purchase. Pass it back as the card-transaction
						reference on expense-entry-writable to file a receipt against this purchase.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="description" type="xs:string" minOccurs="0"/>
			<xs:element name="merchant" type="xs:string" minOccurs="0"/>
			<xs:element name="card-number" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The last four digits of the card, with the preceding digits masked. Enough to
						recognise a card that is not registered as a company card in Kleer; use
						company-card below when the purchase matched a registered card.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<!-- The company card this purchase was made with, when one is registered with a matching card
			     number. Present it back as expense-entry-writable/company-card when filing the receipt:
			     the save is rejected if a matching card exists and the entry carries a different one. -->
			<xs:element name="company-card" type="company-card-readable" minOccurs="0"/>
			<!-- What the purchase cost, in the currency it was made in. Informational: these are not the
			     values to file the receipt with when the purchase has a company-card, see billing-amount. -->
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="vat" type="xs:long">
				<xs:annotation>
					<xs:documentation>
						The VAT the card issuer reports for the purchase. File it as the entry's vat only when
						the entry is filed with the company's own country-code: no VAT may be claimed on a
						receipt from another country, and such an entry is rejected with a conflict however
						much this field reports.

						The rule is evaluated against the country-code on the entry, not the one below, so it
						is the entry's own country that decides. See the country-code documentation below.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="currency-type" type="xs:string"/>
			<xs:element name="billing-amount" type="xs:long">
				<xs:annotation>
					<xs:documentation>
						What the card was actually charged, in billing-currency-type. This is the pair to file
						a receipt with when the purchase has a company-card: the entry's amount and
						currency-type must equal billing-amount and billing-currency-type, not the purchase
						amount and currency above. Filing the purchase amount for a purchase made in another
						currency is rejected as a conflict, with a message about changing the amount.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="billing-currency-type" type="xs:string"/>
			<xs:element name="country-code" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Where the card issuer says the purchase was made, and the value to copy onto the entry
						unless the receipt itself says otherwise. It is a suggestion, not a constraint: the
						entry may be filed with a different country-code and is not rejected for disagreeing
						with this one, the same way the form in Kleer lets the country be changed and prefers
						the country of a previous receipt from the same merchant over this value.

						What it does decide is VAT. The entry's own country-code is compared with the
						company's, and an entry from another country may not carry VAT. So copying this value
						onto the entry means vat must be 0 whenever it differs from the company's country.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="reservation" type="xs:boolean">
				<xs:annotation>
					<xs:documentation>
						True while the purchase is a reservation we have not registered an authorisation
						for: an expense filed against it cannot be bundled into an expense report yet.
						False once the authorisation is registered, including for purchases that started
						as a reservation.

						Computed from our own reservation and authorisation records, while the amounts
						above come from the card issuer. The two can disagree - the issuer may have
						authorised a purchase whose authorisation never reached us - in which case this
						is true next to amounts that are already final. That is deliberate: it answers
						whether the purchase can be filed and bundled, which is the promise a caller
						acts on, not what the issuer currently reports.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="card-transaction-reference">
		<xs:sequence>
			<xs:element name="key" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-entry-readables">
		<xs:sequence>
			<xs:element name="expense-entry" type="expense-entry-readable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-entry-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="expense-nr" type="xs:int" minOccurs="0"/>
			<!-- expense-file, company-card, expense-type and persons are only present for regular (receipt) entries.
			     Mileage and allowance entries instead carry the expense-mileage / expense-allowance element below. -->
			<xs:element name="expense-file" type="expense-file-reference" minOccurs="0"/>
			<xs:element name="company-card" type="company-card-readable" minOccurs="0"/>
			<xs:element name="expense-type" type="expense-type-readable" minOccurs="0"/>
			<xs:element name="persons" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="digital" type="xs:boolean"/>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="vat" type="xs:long"/>
			<xs:element name="currency-type" type="xs:string"/>
			<xs:element name="currency-rate" type="xs:decimal"/>
			<xs:element name="country-code" type="xs:string"/>
			<xs:element name="registration-date" type="xs:dateTime"/>
			<xs:element name="period-start-date" type="xs:date"/>
			<xs:element name="period-end-date" type="xs:date"/>
			<xs:element name="dimension-entries">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="dimension-entry" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="id" type="xs:int"/>
									<xs:element name="name" type="xs:string"/>
									<xs:element name="dimension">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="id" type="xs:int"/>
												<xs:element name="name" type="xs:string"/>
											</xs:sequence>
										</xs:complexType>
									</xs:element>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="re-invoicing">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="client-project" minOccurs="0">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="id" type="xs:int"/>
									<xs:element name="name" type="xs:string"/>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<!-- Present only for mileage entries (milersättning). -->
			<xs:element name="expense-mileage" type="expense-mileage-readable" minOccurs="0"/>
			<!-- Present only for per-diem / allowance entries (traktamente). -->
			<xs:element name="expense-allowance" type="expense-allowance-readable" minOccurs="0"/>
			<!-- Present only when the receipt is filed against a card purchase. -->
			<xs:element name="card-transaction" type="card-transaction-reference" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-mileage-readable">
		<xs:sequence>
			<xs:element name="type" type="xs:string">
				<xs:annotation>
					<xs:documentation>Mileage entry type. One of: "Single" (a single trip, with start/end descriptions and optional coordinates) or "Batch" (an aggregated driving-logbook entry, where start/end descriptions may be absent).</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="amount-taxfree" type="xs:long">
				<xs:annotation>
					<xs:documentation>Tax-free reimbursement amount for the trip, in cents.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="amount-taxed" type="xs:long">
				<xs:annotation>
					<xs:documentation>Taxable reimbursement amount for the trip, in cents.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="round-trip" type="xs:boolean"/>
			<xs:element name="distance-one-way-km" type="xs:decimal">
				<xs:annotation>
					<xs:documentation>One-way travel distance, in kilometres.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="distance-total-km" type="xs:decimal">
				<xs:annotation>
					<xs:documentation>Total travel distance in kilometres; equals distance-one-way-km, doubled when round-trip is true.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="start-description" type="xs:string" minOccurs="0"/>
			<xs:element name="end-description" type="xs:string" minOccurs="0"/>
			<xs:element name="start-latitude" type="xs:decimal" minOccurs="0"/>
			<xs:element name="start-longitude" type="xs:decimal" minOccurs="0"/>
			<xs:element name="end-latitude" type="xs:decimal" minOccurs="0"/>
			<xs:element name="end-longitude" type="xs:decimal" minOccurs="0"/>
			<xs:element name="car-id" type="xs:int" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-allowance-readable">
		<xs:sequence>
			<xs:element name="purpose" type="xs:string"/>
			<xs:element name="trip-origin-description" type="xs:string"/>
			<xs:element name="domestic" type="xs:boolean"/>
			<xs:element name="breakfast-payment" type="xs:string"/>
			<xs:element name="lunch-payment" type="xs:string"/>
			<xs:element name="dinner-payment" type="xs:string"/>
			<xs:element name="night-allowance" type="xs:boolean"/>
			<xs:element name="benefits-amount" type="xs:long">
				<xs:annotation>
					<xs:documentation>Taxable benefit (förmån) for provided meals, in cents.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="days">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="day" type="expense-allowance-day-readable" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="trips">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="trip" type="expense-allowance-trip-readable" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-allowance-day-readable">
		<xs:sequence>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="breakfast-payment" type="xs:string"/>
			<xs:element name="lunch-payment" type="xs:string"/>
			<xs:element name="dinner-payment" type="xs:string"/>
			<xs:element name="night-allowance" type="xs:boolean"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-allowance-trip-readable">
		<xs:sequence>
			<xs:element name="start-time" type="xs:dateTime"/>
			<xs:element name="end-time" type="xs:dateTime"/>
			<xs:element name="destination-country-code" type="xs:string"/>
			<xs:element name="destination-description" type="xs:string" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="car-readable">
		<xs:annotation>
			<xs:documentation>A user's registered car (the car-id returned in expense-mileage). Requires payroll read access.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="registration-number" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>The car's registration number. Absent if none is registered.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="car-code" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>Skatteverket model code (Modellkod) for benefit cars; format YY+model+nr (e.g. 24ABC123). Absent if not set.</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-entry-form">
		<xs:sequence>
			<xs:element name="company-cards">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="company-card" type="company-card-readable" minOccurs="0"
									maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="expense-types">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="expense-type" type="expense-type-readable" minOccurs="0"
									maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="currency-types">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="currency-type" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="countries">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="country" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="code" type="xs:string"/>
									<xs:element name="vat-percentages">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="vat-percentage" type="xs:decimal" minOccurs="0"
															maxOccurs="unbounded"/>
											</xs:sequence>
										</xs:complexType>
									</xs:element>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="dimensions">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="dimension" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="id" type="xs:int"/>
									<xs:element name="name" type="xs:string"/>
									<xs:element name="required" type="xs:boolean"/>
									<xs:element name="entries">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="entry" minOccurs="0" maxOccurs="unbounded">
													<xs:complexType>
														<xs:sequence>
															<xs:element name="id" type="xs:int"/>
															<xs:element name="name" type="xs:string"/>
														</xs:sequence>
													</xs:complexType>
												</xs:element>
											</xs:sequence>
										</xs:complexType>
									</xs:element>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="re-invoicing">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="client-project" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="id" type="xs:int"/>
									<xs:element name="name" type="xs:string"/>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-entry-form-defaults">
		<xs:sequence>
			<xs:element name="company-card" type="company-card-readable" minOccurs="0"/>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="type" type="expense-type-readable" minOccurs="0"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="digital" type="xs:boolean"/>
			<xs:element name="currency-type" type="xs:string"/>
			<xs:element name="country-code" type="xs:string"/>
			<xs:element name="dimensions">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="dimension" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="id" type="xs:int"/>
									<xs:element name="name" type="xs:string"/>
									<xs:element name="entry">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="id" type="xs:int"/>
												<xs:element name="name" type="xs:string"/>
											</xs:sequence>
										</xs:complexType>
									</xs:element>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-type-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="classification" type="expense-type-classification"/>
			<xs:element name="dimensions">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="dimension" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="id" type="xs:int"/>
									<xs:element name="name" type="xs:string"/>
									<xs:element name="entry">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="id" type="xs:int"/>
												<xs:element name="name" type="xs:string"/>
											</xs:sequence>
										</xs:complexType>
									</xs:element>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-file-readables">
		<xs:sequence>
			<xs:element name="expense-file" minOccurs="0" maxOccurs="unbounded">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="id" type="xs:int"/>
						<xs:element name="description" type="xs:string"/>
						<xs:element name="filename" type="xs:string"/>
						<xs:element name="thumbnail" type="xs:hexBinary"/>
						<xs:element name="registration-date" type="xs:dateTime"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-readables">
		<xs:sequence>
			<xs:element name="expense" minOccurs="0" maxOccurs="unbounded">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="id" type="xs:int"/>
						<xs:element name="nr" type="xs:int"/>
						<xs:element name="date" type="xs:date"/>
						<xs:element name="company-card" type="company-card-readable" minOccurs="0" maxOccurs="1">
							<xs:annotation>
								<xs:documentation>
									This element id deprecated. As a single expense can contain entries with different company-cards.
									See expense-entry-readable for its actual company-card value.
									Value here is unspecified if multiple company-cards in expense.
								</xs:documentation>
							</xs:annotation>
						</xs:element>
						<xs:element name="amount" type="xs:long"/>
						<xs:element name="currency-type" type="xs:string"/>
						<!--When payment has been done through an extra payout only-->
						<xs:element name="reimbursed" type="xs:boolean"/>
						<!-- For all types of payouts -->
						<xs:element name="paid" type="xs:boolean"/>
						<xs:element name="entries" type="xs:int"/>
						<xs:element name="certified" type="xs:boolean"/>
						<!-- Whether the expense has been approved (by another user, typically managager). All certified expenses are considered approved -->
						<xs:element name="approved" type="xs:boolean"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="company-card-readables">
		<xs:annotation>
			<xs:documentation>The company's active company cards. Requires read access to company cards.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="company-card" type="company-card-readable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="company-card-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="name" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="user-authentication">
		<xs:sequence>
			<xs:element name="email" type="xs:string"/>
			<xs:element name="password" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="tokens">
		<xs:sequence>
			<xs:element name="token" type="token" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="token">
		<xs:sequence>
			<xs:element name="company">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="id" type="xs:int"/>
						<xs:element name="name" type="xs:string"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="value" type="xs:string"/>
			<xs:element name="main" type="xs:boolean"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="accessible-companies">
		<xs:sequence>
			<xs:element name="accessible-company" type="accessible-company" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="accessible-company">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="active" type="xs:boolean"/>
			<xs:element name="main" type="xs:boolean"/>
			<xs:element name="token" type="xs:string"/>
			<xs:element name="accounting-currency-type" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						Main currency type for the company, ie the accounting currency type.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="accesses">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="type" type="access-type" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="access-roles" type="access-roles"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="account-metadatas">
		<xs:sequence>
			<xs:element name="account" type="account-metadata" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="account-metadata">
		<xs:sequence>
			<xs:element name="accountNr" type="xs:int"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="in-balance" type="xs:long"/>
			<xs:element name="out-balance" type="xs:long"/>
			<xs:element name="debit-count" type="xs:int"/>
			<xs:element name="credit-count" type="xs:int"/>
			<xs:element name="disabled" type="xs:boolean"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-event">
		<xs:sequence>
			<!-- Ignored when writing, set when reading -->
			<xs:element name="id" type="xs:int" minOccurs="0"/>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="hours" type="xs:decimal"/>
			<xs:element name="type" type="payroll-event-type"/>
			<xs:element name="child" type="xs:string" minOccurs="0"/>
			<xs:element name="comment" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-child">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="birth-date" type="xs:date"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-events">
		<xs:sequence>
			<xs:element name="payroll-event" type="payroll-event" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-invoice-templates">
		<xs:sequence>
			<xs:element name="client-invoice-template" type="client-invoice-template" minOccurs="0"
						maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-invoice-template">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="accounting-year-readables">
		<xs:sequence>
			<xs:element name="accounting-year-readable" type="accounting-year-readable" minOccurs="0"
						maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="accounting-year-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="start-date" type="xs:date"/>
			<xs:element name="end-date" type="xs:date"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="accounting-year-restriction-readables">
		<xs:sequence>
			<xs:element name="accounting-year-restriction-readable" type="accounting-year-restriction-readable" minOccurs="0"
						maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="accounting-year-restriction-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>

			<xs:element name="accounting-year-id" type="xs:int"/>
			<xs:element name="type" type="accounting-year-restriction-type"/>

			<xs:element name="start-date" type="xs:date"/>
			<xs:element name="end-date" type="xs:date"/>

			<xs:element name="comment" type="xs:string"/>
			<xs:element name="registration-user" type="user-reference"/>
			<xs:element name="registration-date" type="xs:dateTime"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="voucher-readable">
		<xs:sequence>
			<xs:element name="serie" type="xs:string"/>
			<xs:element name="number" type="xs:long"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="turnover" type="xs:long"/>
			<xs:element name="transactions">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="transaction" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>

									<xs:element name="account-nr" type="xs:int"/>

									<xs:element name="vat-code" type="vat-code-type" minOccurs="0">
										<xs:annotation>
											<xs:documentation>
												Vat code used for this transaction.
											</xs:documentation>
										</xs:annotation>
									</xs:element>
									<xs:element name="orgno" type="xs:string" minOccurs="0"/>
									<xs:element name="amount" type="xs:long"/>
									<xs:element name="dimension-entries">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="dimension-entry" minOccurs="0" maxOccurs="unbounded">
													<xs:complexType>
														<xs:sequence>
															<xs:element name="id" type="dimension-entry-reference"/>
															<xs:element name="amount" type="xs:long"/>
														</xs:sequence>
													</xs:complexType>
												</xs:element>
											</xs:sequence>
										</xs:complexType>
									</xs:element>
									<xs:element name="currency-amounts">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="currency-amount" maxOccurs="unbounded">
													<xs:complexType>
														<xs:sequence>
															<xs:element name="currency-type" type="xs:string"/>
															<xs:element name="amount" type="xs:long"/>
														</xs:sequence>
													</xs:complexType>
												</xs:element>
											</xs:sequence>
										</xs:complexType>
									</xs:element>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="vouchers-readable">
		<xs:sequence>
			<xs:element name="voucher-readable" type="voucher-readable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="voucher-writeable">
		<xs:sequence>
			<xs:element name="serie" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="comments" type="xs:string"/>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="transactions">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="transaction" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>

									<xs:element name="account-nr" type="xs:int"/>

									<xs:element name="vat-code" type="vat-code-type" nillable="true" minOccurs="0">
										<xs:annotation>
											<xs:documentation>
												Vat code used for this transaction, or null if none. If at least
												one transaction in the voucher has this element, all transactions
												will be vat coded according to the given definition. If no transactions
												have this element, vat codes will be assigned automatically based
												on account number.
											</xs:documentation>
										</xs:annotation>
									</xs:element>

									<xs:element name="orgno" type="xs:string" minOccurs="0"/>

									<xs:element name="amount" type="xs:long"/>

									<xs:choice minOccurs="0">

										<xs:annotation>
											<xs:documentation>
												Optional dimension information for this transaction. Usage of
												project-element is deprecated, please use dimensions instead.
											</xs:documentation>
										</xs:annotation>

										<xs:element name="project" type="project-reference"/>
										<xs:element name="dimensions" type="dimensions-distribution"/>

									</xs:choice>

									<xs:choice minOccurs="0">

										<xs:annotation>
											<xs:documentation>
												Optional currency information for this transaction. One of the
												elements should be used.
											</xs:documentation>
										</xs:annotation>

										<xs:element name="currency-type" type="xs:string">
											<xs:annotation>
												<xs:documentation>
													Currency that amount on transaction is specified in. The actual
													accounting amount will then be automatically determined using
													the exchange rate on the voucher's date.
												</xs:documentation>
											</xs:annotation>
										</xs:element>

										<xs:element name="currency-amount">
											<xs:annotation>
												<xs:documentation>
													Explicit currency amount information for this transaction. Amount
													on transaction is implicitely assumed to be in the accounting
													currency.
												</xs:documentation>
											</xs:annotation>
											<xs:complexType>
												<xs:sequence>
													<xs:element name="currency-type" type="xs:string"/>
													<xs:element name="amount" type="xs:long"/>
												</xs:sequence>
											</xs:complexType>
										</xs:element>

									</xs:choice>

								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="files">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" minOccurs="0" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="voucher-detailed">
		<xs:sequence>

			<xs:element name="serie" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						The serie that this voucher belongs to.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="number" type="xs:long">
				<xs:annotation>
					<xs:documentation>
						The voucher's number in its given serie. Two vouchers in the same serie can not have
						the same number within the same accounting year.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="description" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						The description of the voucher
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="date" type="xs:date">
				<xs:annotation>
					<xs:documentation>
						The voucher's transaction date
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="transactions">
				<xs:annotation>
					<xs:documentation>
						The transactions associated with this voucher.
					</xs:documentation>
				</xs:annotation>
				<xs:complexType>
					<xs:sequence>
						<xs:element name="transaction" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>

									<xs:element name="account-nr" type="xs:int">
										<xs:annotation>
											<xs:documentation>
												The account number for this transaction.
											</xs:documentation>
										</xs:annotation>
									</xs:element>

									<xs:element name="vat-code" type="vat-code-type" minOccurs="0">
										<xs:annotation>
											<xs:documentation>
												Vat code used for this transaction.
											</xs:documentation>
										</xs:annotation>
									</xs:element>
									<xs:element name="orgno" type="xs:string" minOccurs="0"/>
									<xs:element name="transaction-id" type="xs:int">
										<xs:annotation>
											<xs:documentation>
												The internal identification used for this transaction
											</xs:documentation>
										</xs:annotation>
									</xs:element>

									<xs:element name="amount" type="xs:long">
										<xs:annotation>
											<xs:documentation>
												The accounting amount for this transaction.
											</xs:documentation>
										</xs:annotation>
									</xs:element>

									<xs:element name="references">
										<xs:annotation>
											<xs:documentation>
												The set of references associated with this transaction, always at least
												one. On a reference,
												further detailed information will be found, such as currency amount and
												any dimension entries.
											</xs:documentation>
										</xs:annotation>
										<xs:complexType>
											<xs:sequence>
												<xs:element name="reference" maxOccurs="unbounded">
													<xs:complexType>
														<xs:sequence>

															<xs:element name="type">
																<xs:annotation>
																	<xs:documentation>
																		The type of this reference, e.g. where does this
																		reference point?
																	</xs:documentation>
																</xs:annotation>
																<xs:complexType>
																	<xs:choice>
																		<xs:element name="client-invoice-row"
																					type="client-invoice-row-reference"/>
																		<xs:element name="expense-entry"
																					type="expense-entry-reference"/>
																		<xs:element name="supplier-invoice-account"
																					type="supplier-invoice-account-reference"/>
																		<xs:element name="revenue-row" type="revenue-row-reference"/>
																		<xs:element name="none">
																			<xs:annotation>
																				<xs:documentation>
																					No specific reference, the
																					transaction itself is the reference.
																					This is the
																					default case.
																				</xs:documentation>
																			</xs:annotation>
																			<xs:complexType/>
																		</xs:element>
																		<xs:element name="other">
																			<xs:complexType/>
																		</xs:element>
																	</xs:choice>
																</xs:complexType>
															</xs:element>

															<xs:element name="transaction-reference-id" type="xs:int">
																<xs:annotation>
																	<xs:documentation>
																		The internal identification used for this transaction reference
																	</xs:documentation>
																</xs:annotation>
															</xs:element>

															<xs:element name="amount" type="xs:long">
																<xs:annotation>
																	<xs:documentation>
																		The accounting amount for this reference. The
																		sum of all reference amounts is guranteed to
																		be equal to the transaction's amount.
																	</xs:documentation>
																</xs:annotation>
															</xs:element>

															<xs:element name="currency-amount" type="currency-amount"/>

															<xs:element name="dimension-entries">
																<xs:complexType>
																	<xs:sequence>
																		<xs:element name="dimension-entry" minOccurs="0"
																					maxOccurs="unbounded">
																			<xs:complexType>
																				<xs:sequence>
																					<xs:element name="id"
																								type="xs:int"/>
																					<xs:element name="dimension"
																								type="dimension-reference"/>
																					<xs:element name="amount"
																								type="xs:long"/>
																					<xs:element name="currency-amount"
																								type="currency-amount"/>
																				</xs:sequence>
																			</xs:complexType>
																		</xs:element>
																	</xs:sequence>
																</xs:complexType>
															</xs:element>

														</xs:sequence>
													</xs:complexType>
												</xs:element>
											</xs:sequence>
										</xs:complexType>
									</xs:element>

								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="currency-amount">
		<xs:sequence>
			<xs:element name="currency-type" type="xs:string"/>
			<xs:element name="amount" type="xs:long"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-user-readables">
		<xs:sequence>
			<xs:element name="payroll-user-readable" type="payroll-user-readable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-user-readable">
		<xs:sequence>
			<xs:element name="user" type="user-reference"/>
			<xs:element name="ssn" type="xs:string"/>
			<xs:element name="address1" type="xs:string"/>
			<xs:element name="address2" type="xs:string"/>
			<xs:element name="zip-code" type="xs:string"/>
			<xs:element name="state" type="xs:string"/>
			<!-- ISO 3166-1 alpha-2 code -->
			<xs:element name="country-code" type="xs:string"/>
			<xs:element name="phone" type="xs:string"/>
			<xs:element name="tax-table" type="xs:int"/>
			<xs:element name="tax-table-column" type="xs:int"/>
			<xs:element name="tax-percentage" type="xs:decimal"/>
			<xs:element name="tax-percentage-valid-from" type="xs:date" minOccurs="0"/>
			<xs:element name="tax-percentage-valid-to" type="xs:date" minOccurs="0"/>
			<xs:element name="one-time-tax-percentage" type="xs:decimal"/>
			<xs:element name="clearing-nr" type="xs:string"/>
			<xs:element name="account-nr" type="xs:string"/>
			<xs:element name="employment-start-date" type="xs:date"/>
			<xs:element name="employment-end-date" type="xs:date" minOccurs="0"/>
			<xs:element name="notes" type="xs:string" minOccurs="0"/>
			<xs:element name="travel-reimbursement-per-mile" type="xs:long"/>
			<xs:element name="expense-allowance" type="xs:boolean"/>
			<xs:element name="fuel-benefit" type="xs:boolean"/>
			<xs:element name="monthly-salary-type" type="payroll-user-monthly-salary-type"/>
			<xs:element name="monthly-salary" type="xs:long"/>
			<xs:element name="monthly-salary-start-date" type="xs:date" minOccurs="0"/>
			<xs:element name="monthly-salary-yearly-pension" type="xs:long"/>
			<xs:element name="hourly-salary" type="xs:long"/>
			<xs:element name="hourly-salary-start-date" type="xs:date" minOccurs="0"/>
			<xs:element name="variable-salary-type" type="payroll-user-variable-salary-type"/>
			<xs:element name="variable-salary-payout-type" type="payroll-user-variable-salary-payout-type"/>
			<xs:element name="variable-salary-input-type" type="payroll-user-variable-salary-input-type"/>
			<xs:element name="variable-salary-description" type="xs:string"/>
			<xs:element name="variable-salery-tax-type" type="payroll-user-variable-tax-type"/>
			<xs:element name="variable-salery-provision-vacation-percentage" type="xs:decimal"/>
			<xs:element name="provision" type="xs:boolean"/>
			<xs:element name="month-report-strategy" type="payroll-user-month-report-strategy"/>
			<xs:element name="manager-user" type="user-reference"/>
			<xs:element name="workplace-number" type="xs:string"/>
			<xs:element name="workplace-custom-address" type="xs:string" minOccurs="0"/>
			<xs:element name="workplace-custom-locality" type="xs:string" minOccurs="0"/>
			<xs:element name="vacationFixedDebtPercentage" type="xs:decimal" minOccurs="0"/>

			<!-- Vacation Balances -->
			<xs:element name="vacation-entitlement" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-paid-days" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-paid-days-used" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-advance-days" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-advance-days-used" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-advance-days-previous-year" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-saved-days" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-saved-days-year-1" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-saved-days-year-2" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-saved-days-year-3" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-saved-days-year-4" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-saved-days-year-5" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-saved-days-used" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-unpaid-days" type="xs:decimal" minOccurs="0"/>
			<xs:element name="vacation-unpaid-days-used" type="xs:decimal" minOccurs="0"/>

			<xs:element name="schedules">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="schedule" type="payroll-user-schedule" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="dimension-entries">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="dimension-entry" type="dimension-entry-reference"
									minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="vacation-entitlements">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="vacation-entitlement" type="vacation-entitlement" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="children">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="child" type="payroll-child" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="full-history-monthly-salaries">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="full-history-monthly-salary" type="full-history-monthly-salary" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="comp-time-balance" type="xs:decimal">
				<xs:annotation>
					<xs:documentation>
						The employee's comp time (flex/overtime) balance in hours, as of now.
						Negative when the employee owes hours.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="full-history-monthly-salary">
		<xs:sequence>
			<xs:element name="monthly-salary" type="xs:long"/>
			<xs:element name="monthly-salary-start-date" type="xs:date"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-user-writable">
		<xs:sequence>

			<!--
			Only non-null fields will be updated/set. When creating a new payroll-user, the following fields
			are required. Remaining will be set with default values.
			* ssn
			* employment-start-date
			-->

			<xs:element name="ssn" type="xs:string" minOccurs="0"/>
			<xs:element name="address1" type="xs:string" minOccurs="0"/>
			<xs:element name="address2" type="xs:string" minOccurs="0"/>
			<xs:element name="zip-code" type="xs:string" minOccurs="0"/>
			<xs:element name="state" type="xs:string" minOccurs="0"/>
			<!-- ISO 3166-1 alpha-2 code -->
			<xs:element name="country-code" type="xs:string" minOccurs="0"/>
			<xs:element name="phone" type="xs:string" minOccurs="0"/>
			<xs:element name="tax-table" type="xs:int" minOccurs="0"/>
			<xs:element name="tax-table-column" type="xs:int" minOccurs="0"/>
			<xs:element name="tax-percentage" type="xs:decimal" minOccurs="0"/>
			<xs:element name="tax-percentage-valid-from" type="xs:date" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date from which the tax percentage is valid.
						Required when tax-percentage is set. If omitted, defaults to January 1st of the current year.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="tax-percentage-valid-to" type="xs:date" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date until which the tax percentage is valid.
						Required when tax-percentage is set. If omitted, defaults to December 31st of the current year.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="one-time-tax-percentage" type="xs:decimal" minOccurs="0"/>
			<xs:element name="clearing-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="account-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="employment-start-date" type="xs:date" minOccurs="0"/>

			<!--
			 Wrapped element in order to be able to distinguish between the cases
			 "remove existing value" and "leave existing value unmodified"
			 -->
			<xs:element name="employment-end-date" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="employment-end-date" type="xs:date" minOccurs="0"/>
						<xs:element name="employment-end-type" type="payroll-user-employment-end-type" minOccurs="0"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="notes" type="xs:string" minOccurs="0"/>
			<xs:element name="travel-reimbursement-per-mile" type="xs:long" minOccurs="0"/>
			<xs:element name="expense-allowance" type="xs:boolean" minOccurs="0"/>
			<xs:element name="fuel-benefit" type="xs:boolean" minOccurs="0"/>
			<xs:element name="monthly-salary-type" type="payroll-user-monthly-salary-type" minOccurs="0"/>
			<xs:element name="monthly-salary" type="xs:long" minOccurs="0"/>
			<xs:element name="monthly-salary-start-date" type="xs:date" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date from which the specified monthly-salary is valid from.
						If omitted, default start date is start of current month.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="monthly-salary-yearly-pension" type="xs:long" minOccurs="0"/>
			<xs:element name="hourly-salary" type="xs:long" minOccurs="0"/>
			<xs:element name="hourly-salary-start-date" type="xs:date" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date from which the specified hourly-salary is valid from.
						If omitted, default start date is start of current month.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="provision" type="xs:boolean" minOccurs="0"/>
			<xs:element name="month-report-strategy" type="payroll-user-month-report-strategy" minOccurs="0"/>

			<!-- Skip to leave current schedules as is -->
			<xs:element name="schedules" minOccurs="0">
				<xs:complexType>
					<xs:sequence>

						<!-- Overwrites existing schedules, Ie 0 occurs clears all schedules -->
						<xs:element name="schedule" type="payroll-user-schedule" minOccurs="0"
									maxOccurs="unbounded"/>

					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!-- Skip to leave current dimension entries as is -->
			<xs:element name="dimension-entries" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="dimension-entry" type="dimension-entry-reference"
									minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="manager-user" type="user-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Sets the manager of this payroll user. Skip to leave the current manager as is.
						The id must reference an existing user in this company; an omitted, null or zero id
						is rejected. Use remove-manager-user to remove the current manager.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="remove-manager-user" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Set to true to remove the current manager. Mutually exclusive with manager-user.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="vacation-entitlement" type="vacation-entitlement" minOccurs="0"/>
			<xs:element name="workplace-number" type="xs:string" minOccurs="0"/>
			<xs:element name="workplace-custom-address" type="xs:string" minOccurs="0"/>
			<xs:element name="workplace-custom-locality" type="xs:string" minOccurs="0"/>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-user-schedule">
		<xs:sequence>
			<xs:element name="schedule" type="payroll-schedule-reference"/>
			<xs:element name="start-date" type="xs:date" minOccurs="0"/>
			<xs:element name="end-date" type="xs:date" minOccurs="0"/>
			<xs:element name="comment" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="vacation-entitlement">
		<xs:sequence>
			<xs:element name="start-date" type="xs:date"/>
			<xs:element name="entitlement" type="xs:long"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-run-create">
		<xs:sequence>

			<!-- The desired payment date -->
			<xs:element name="payment-date" type="xs:date"/>

			<!-- All payouts to include in this run -->
			<xs:element name="payouts">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="payout" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>

									<!-- The user for this payout. Referenced user must have an existing payroll agreement -->
									<xs:element name="user" type="user-reference"/>
									<xs:element name="project" type="project-reference" minOccurs="0"/>
									<xs:element name="period-start" type="xs:date"/>
									<xs:element name="period-end" type="xs:date"/>

									<xs:element name="articles">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="benefit" type="payroll-payout-article"
															minOccurs="0"
															maxOccurs="unbounded"/>
												<xs:element name="salary" type="payroll-payout-article"
															minOccurs="0"
															maxOccurs="unbounded"/>
												<xs:element name="provision" type="payroll-payout-article"
															minOccurs="0"
															maxOccurs="unbounded"/>
												<xs:element name="other-articles" type="payroll-payout-article"
															minOccurs="0"
															maxOccurs="unbounded"/>
											</xs:sequence>
										</xs:complexType>
									</xs:element>


								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-runs">
		<xs:complexContent>
			<xs:extension base="paged-result">
				<xs:sequence>
					<xs:element name="payroll-run" type="payroll-run" minOccurs="0" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="payroll-run">
		<xs:sequence>

			<xs:element name="id" type="xs:int"/>
			<!-- Set one run has been paid -->
			<xs:element name="nr" type="xs:int" minOccurs="0"/>
			<xs:element name="payment-date" type="xs:date"/>

			<xs:element name="payouts">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="payout" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="payout-id" type="payroll-payout-reference"/>
									<xs:element name="user" type="user-reference"/>
									<xs:element name="project" type="project-reference" minOccurs="0"/>
									<xs:element name="period-start" type="xs:date"/>
									<xs:element name="period-end" type="xs:date"/>
									<xs:element name="gross" type="xs:long"/>
									<xs:element name="benefits" type="xs:long"/>
									<xs:element name="payout" type="xs:long"/>
									<xs:element name="tax" type="xs:long"/>
									<xs:element name="social-fees" type="xs:long"/>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="paid" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="user" type="user-reference"/>
						<xs:element name="datetime" type="xs:dateTime"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!-- Info text for warnings such as bookkeeping being uncertain -->
			<xs:element name="info" type="xs:string" minOccurs="0"/>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-run-pay">
		<xs:sequence>
			<xs:element name="payment-date" type="xs:date" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-run-bookkeep">
		<xs:sequence>
			<xs:element name="payment-date" type="xs:date" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-transactions">
		<xs:complexContent>
			<xs:extension base="paged-result">
				<xs:sequence>
					<xs:element name="payroll-transaction" type="payroll-transaction" minOccurs="0" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="payroll-transaction">
		<xs:sequence>

			<xs:element name="id" type="xs:int"/>
			<xs:element name="user" type="user-reference"/>
			<xs:element name="payroll-payout" type="payroll-payout-reference"/>
			<xs:element name="payroll-article" type="payroll-article-reference"/>
			<xs:element name="period" type="period"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="quantity" type="xs:decimal"/>
			<xs:element name="unit" type="payroll-unit-type"/>
			<xs:element name="price" type="xs:long"/>
			<xs:element name="social-fees" type="xs:long"/>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-payout-article">
		<xs:sequence>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="quantity" type="xs:decimal"/>
			<xs:element name="price" type="xs:long"/>
			<xs:element name="project" type="project-reference" minOccurs="0"/>
			<!-- Article will be overwritten if payroll-payout-article in payroll-run-create benefit, salary or provision. Will be used in other-articles -->
			<xs:element name="article" type="payroll-article-reference" minOccurs="0"/>
			<xs:element name="period" type="period" minOccurs="0"/>
			<xs:element name="dimensions" type="dimensions-distribution" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-month-report-writeable">
		<xs:sequence>

			<!-- Skip to leave current provision as is -->
			<xs:element name="provisions" minOccurs="0">
				<xs:complexType>
					<xs:sequence>

						<!-- Overwrites existing provisions, Ie 0 occurs clears all provisions -->
						<xs:element name="provision" type="payroll-month-report-provision" minOccurs="0"
									maxOccurs="unbounded"/>

					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!-- Skip to leave current articles as is -->
			<xs:element name="articles" minOccurs="0">
				<xs:complexType>
					<xs:sequence>

						<!-- Overwrites existing articles, Ie 0 occurs clears all articles -->
						<xs:element name="article" type="payroll-month-report-article" minOccurs="0"
									maxOccurs="unbounded"/>

					</xs:sequence>
				</xs:complexType>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-month-report-readables">
		<xs:sequence>
			<xs:element name="payroll-month-report-readable" type="payroll-month-report-readable" minOccurs="0"
						maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-month-report-readable">
		<xs:sequence>

			<xs:element name="user" type="user-reference"/>
			<xs:element name="year" type="xs:int"/>

			<!-- January = 0, December = 11 -->
			<xs:element name="month" type="xs:int"/>

			<xs:element name="provisions">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="provision" type="payroll-month-report-provision" minOccurs="0"
									maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="notes" type="xs:string"/>

			<xs:element name="gross" type="xs:long"/>
			<xs:element name="benefits" type="xs:long"/>
			<xs:element name="payout" type="xs:long"/>
			<xs:element name="tax" type="xs:long"/>
			<xs:element name="social-fees" type="xs:long"/>

			<xs:element name="articles">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="article" type="payroll-month-report-article" minOccurs="0"
									maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="approved" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="user" type="user-reference"/>
						<xs:element name="datetime" type="xs:dateTime"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="certified" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="user" type="user-reference"/>
						<xs:element name="datetime" type="xs:dateTime"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-month-report-provision">
		<xs:sequence>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="project" type="project-reference" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-month-report-article">
		<xs:sequence>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="article" type="payroll-article-reference"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="quantity" type="xs:decimal"/>
			<xs:element name="price" type="xs:long"/>
			<xs:element name="unit" type="payroll-unit-type"/>
			<xs:element name="period" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="start" type="xs:date"/>
						<xs:element name="end" type="xs:date"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="project" type="project-reference" minOccurs="0"/>
			<xs:element name="dimensions" type="dimensions-distribution" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-article-readables">
		<xs:sequence>
			<xs:element name="payroll-article-readable" type="payroll-article-readable" minOccurs="0"
						maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-article-readable">
		<xs:sequence>
			<xs:element name="id" type="payroll-article-reference"/>
			<xs:element name="name" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-schedules-readable">
		<xs:choice minOccurs="0" maxOccurs="unbounded">
			<xs:element name="rolling-schedule" type="payroll-rolling-schedule-readable"/>
			<xs:element name="fixed-schedule" type="payroll-fixed-schedule-readable"/>
		</xs:choice>
	</xs:complexType>

	<xs:complexType name="payroll-schedule-readable">
		<xs:choice>
			<xs:element name="rolling-schedule" type="payroll-rolling-schedule-readable"/>
			<xs:element name="fixed-schedule" type="payroll-fixed-schedule-readable"/>
		</xs:choice>
	</xs:complexType>

	<xs:complexType name="payroll-rolling-schedule-writeable">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>

			<!-- Skip to leave current intervals as is -->
			<xs:element name="intervals" minOccurs="0">
				<xs:complexType>
					<xs:sequence>

						<!-- Overwrites existing intervals, Ie 0 occurs clears all intervals -->
						<xs:element name="interval" type="payroll-rolling-schedule-interval" minOccurs="0"
									maxOccurs="unbounded"/>

					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-rolling-schedule-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>

			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>

			<xs:element name="weeks" type="xs:int"/>
			<xs:element name="hours-per-week" type="xs:decimal"/>
			<xs:element name="days-per-week" type="xs:decimal"/>
			<xs:element name="level-of-employment" type="xs:decimal"/>
			<xs:element name="usage-count" type="xs:int" minOccurs="0"/>
			<xs:element name="editable" type="xs:boolean"/>

			<xs:element name="intervals">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="interval" type="payroll-rolling-schedule-interval" minOccurs="0"
									maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-fixed-schedule-writeable">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="hours-per-week" type="xs:decimal" minOccurs="0"/>
			<xs:element name="days-per-week" type="xs:decimal" minOccurs="0"/>
			<xs:element name="level-of-employment" type="xs:decimal" minOccurs="0"/>

			<!-- Skip to leave current intervals as is -->
			<xs:element name="intervals" minOccurs="0">
				<xs:complexType>
					<xs:sequence>

						<!-- Overwrites existing intervals, Ie 0 occurs clears all intervals -->
						<xs:element name="interval" type="payroll-fixed-schedule-interval" minOccurs="0"
									maxOccurs="unbounded"/>

					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-fixed-schedule-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>

			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="hours-per-week" type="xs:decimal"/>
			<xs:element name="days-per-week" type="xs:decimal"/>
			<xs:element name="level-of-employment" type="xs:decimal"/>

			<xs:element name="usage-count" type="xs:int" minOccurs="0"/>
			<xs:element name="editable" type="xs:boolean"/>

			<xs:element name="intervals">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="interval" type="payroll-fixed-schedule-interval" minOccurs="0"
									maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-rolling-schedule-interval">
		<xs:sequence>
			<xs:element name="day" type="xs:int"/>

			<xs:element name="hours" type="xs:decimal"/>
			<xs:element name="type" type="payroll-schedule-interval-type"/>
			<xs:element name="comment" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-fixed-schedule-interval">
		<xs:sequence>
			<xs:element name="date" type="xs:date"/>

			<xs:element name="hours" type="xs:decimal"/>
			<xs:element name="type" type="payroll-schedule-interval-type"/>
			<xs:element name="comment" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-user-schedule-metadatas">
		<xs:sequence>
			<xs:element name="payroll-user-schedule-metadata" type="payroll-user-schedule-metadata" minOccurs="0"
						maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-user-schedule-metadata">
		<xs:sequence>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="level-of-employment" type="xs:decimal"/>
			<xs:element name="gross-hours" type="xs:decimal"/>
			<xs:element name="net-hours" type="xs:decimal"/>
			<xs:element name="actual-hours" type="xs:decimal"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="company-information">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="orgno" type="xs:string"/>
			<xs:element name="accounting-currency" type="xs:string"/>
			<xs:element name="bankgiro" type="xs:long" minOccurs="0"/>
			<xs:element name="supplier-invoice-email" type="xs:string"/>
			<xs:element name="expense-email" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="company-message">
		<xs:sequence>

			<xs:element name="subject" type="xs:string"/>
			<xs:element name="message" type="xs:string"/>

			<xs:element name="files">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" minOccurs="0" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="edi-recipient">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="clients">
		<xs:sequence>
			<xs:element name="client" type="client" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client">
		<xs:sequence>

			<xs:element name="id" type="xs:int"/>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="contact" type="xs:string"/>
			<xs:element name="address" type="address"/>
			<xs:element name="email" type="xs:string"/>

			<!-- The client's type -->
			<xs:element name="client-type" type="xs:string" minOccurs="0"/>

			<!-- The client's ISO 3166-1 alpha-2 code -->
			<xs:element name="country-code" type="xs:string"/>

			<!-- The client's currency -->
			<xs:element name="currency-type" type="xs:string" minOccurs="0"/>

			<xs:element name="notes" type="xs:string" minOccurs="0"/>

			<!-- deprecated, set to 0 -->
			<xs:element name="accountnr" type="xs:int"/>
			<xs:element name="payment-days" type="xs:int"/>
			<xs:element name="orgno" type="xs:string"/>
			<xs:element name="phone" type="xs:string"/>
			<xs:element name="user" type="user-reference"/>

			<!-- When creating, leave empty to use default delivery. When saving, leave empty to leave original value unchanged. -->
			<xs:element name="delivery-type" type="xs:string" minOccurs="0"/>

			<xs:element name="vat-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="gln" type="xs:string" minOccurs="0"/>

			<xs:element name="edi-recipient" type="edi-recipient" minOccurs="0"/>

			<xs:element name="fetch-edi-recipient" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Setting this element to true will automatically fetch an EDI-recipient for the given client and apply it if its identities matches strictly.
						If multiple recipients were found, no EDI-recipient will be set.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="template" type="client-invoice-template-reference" minOccurs="0" nillable="true">
				<xs:annotation>
					<xs:documentation>
						Optional template to use as default when creating new client invoices with the client. When
						reading, this
						value is always set, where "null" means "use a reasonable default template". When writing,
						omitting this
						value will set it to "null" when creating, and leave it unchanged with updating.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="approver" type="user-reference" minOccurs="0" nillable="true">
				<xs:annotation>
					<xs:documentation>
						Optional approver to use as default when creating new client invoices with the client. When
						writing, omitting this value will set it to "none" when creating, and leave it unchanged with
						updating.
						When updating, set to null to explicitely clear any previously set value.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="dimension-entries" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Omitting this element will leave dimension-entries unchanged when updating
					</xs:documentation>
				</xs:annotation>
				<xs:complexType>
					<xs:sequence>
						<xs:element name="dimension-entry" type="dimension-entry-reference"
									minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="client-broker" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Omitting this element will leave client-brokers unchanged when updating
					</xs:documentation>
				</xs:annotation>
				<xs:complexType>
					<xs:sequence>
						<xs:element name="client-broker" type="client-broker-reference"
									minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!-- Whether this client is considered active or not -->
			<xs:element name="active" type="xs:boolean" minOccurs="0"/>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="projects">
		<xs:sequence>
			<xs:element name="project" type="project" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="project">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="start-date" type="xs:date" minOccurs="0"/>
			<xs:element name="end-date" type="xs:date" minOccurs="0"/>
			<xs:element name="active" type="xs:boolean"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="projects-metadata">
		<xs:sequence>
			<xs:element name="project" type="project-metadata" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="project-metadata">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="revenue" type="xs:long"/>
			<xs:element name="cost" type="xs:long"/>
			<xs:element name="profit" type="xs:long"/>
			<xs:element name="margin" type="xs:decimal"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="dimensions">
		<xs:sequence>
			<xs:element name="dimension" type="dimension" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="dimension">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="foreign-id" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Value, if set, must be unique.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="active" type="xs:boolean"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="dimension-entries">
		<xs:sequence>
			<xs:element name="dimension-entry" type="dimension-entry" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="dimension-entry">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="foreign-id" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Value, if set, must be unique within its dimension
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="start-date" type="xs:date" minOccurs="0"/>
			<xs:element name="end-date" type="xs:date" minOccurs="0"/>
			<xs:element name="active" type="xs:boolean"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="dimension-entry-writeable">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="foreign-id" type="xs:string" minOccurs="0"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="start-date" type="xs:date" minOccurs="0"/>
			<xs:element name="end-date" type="xs:date" minOccurs="0"/>
			<xs:element name="active" type="xs:boolean"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="company">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="name" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="bank-accounts">
		<xs:sequence>
			<xs:element name="bank-account" type="bank-account" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="bank-account">
		<xs:sequence>
			<xs:element name="id" type="xs:long"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="currency" type="xs:string"/>
			<xs:element name="bic" type="xs:string"/>
			<xs:element name="iban" type="xs:string"/>
			<xs:element name="bankgiro" type="xs:string" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="bank-transactions">
		<xs:complexContent>
			<xs:extension base="paged-result">
				<xs:sequence>
					<xs:element name="bank-transaction" type="bank-transaction" minOccurs="0" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="bank-transaction">
		<xs:sequence>
			<xs:element name="id" type="bank-transaction-reference"/>
			<xs:element name="bank-account" type="bank-account-reference"/>
			<xs:element name="company" type="company"/>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="remaining-amount" type="xs:long"/>
			<xs:element name="reference" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="deleted" type="xs:boolean"/>
			<xs:element name="deleted-date" type="xs:date"/>
			<xs:element name="voucher" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="id" type="xs:int"/>
						<xs:element name="serie-name" type="xs:string"/>
						<xs:element name="number" type="xs:long"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="comments" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="comment" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="messages" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="message" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="files" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" minOccurs="0" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="bgc-metadata" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="bankgiro" type="xs:long" minOccurs="0"/>
						<xs:element name="name" type="xs:string"/>
						<xs:element name="zipcode" type="xs:string"/>
						<xs:element name="country" type="xs:string"/>
						<xs:element name="city" type="xs:string"/>
						<xs:element name="address" type="xs:string"/>
						<xs:element name="orgno" type="xs:string"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="end-to-end-id" minOccurs="0" type="xs:string"/>
			<xs:element name="properties" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="property" type="bank-transaction-property" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="bank-transaction-property">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="value" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="suppliers">
		<xs:sequence>
			<xs:element name="supplier" type="supplier" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="supplier">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="address" type="address"/>
			<xs:element name="email" type="xs:string"/>
			<xs:element name="plusgiro" type="xs:long"/>
			<xs:element name="bankgiro" type="xs:long"/>
			<xs:element name="orgno" type="xs:string" minOccurs="0"/>
			<xs:element name="swedish-bank-account" type="xs:string"/>
			<xs:element name="international-bank-account-with-routing" type="xs:string" minOccurs="0"/>
			<xs:element name="international-bank-account-with-account-number" type="xs:string" minOccurs="0"/>
			<xs:element name="international-bank-account-via-intermediary" type="xs:string" minOccurs="0"/>
			<xs:element name="international-bank-account-in-russia-in-rub" type="xs:string" minOccurs="0"/>
			<xs:element name="norwegian-bank-account" type="xs:string" minOccurs="0"/>
			<!-- Format: [\d\w]+-[\d\w]+ -->
			<xs:element name="iban" type="xs:string"/>
			<!-- your-reference -->
			<xs:element name="user" type="user-reference" minOccurs="0"/>
			<xs:element name="our-reference" type="xs:string" minOccurs="0"/>
			<!-- ISO 3166-1 alpha-2 code -->
			<xs:element name="country-code" type="xs:string" minOccurs="0"/>
			<xs:element name="vat-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="account-nr" type="xs:int" minOccurs="0"/>
			<xs:element name="bank-account" type="bank-account-reference" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="subcontractor-writeable">
		<xs:sequence>
			<xs:element name="supplier" type="supplier-reference"/>
			<xs:element name="users">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="user" type="user-reference" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="subcontractor-readables">
		<xs:sequence>
			<xs:element name="subcontractor-readable" type="subcontractor-readable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="subcontractor-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="internal-id" type="xs:int"/>
			<xs:element name="supplier" type="supplier-reference"/>
			<xs:element name="users">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="user" type="user-reference" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="users">
		<xs:sequence>
			<xs:element name="user" type="user" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="user">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="foreign-id" type="xs:string" minOccurs="0"/>
			<xs:element name="internal-id" type="xs:int" minOccurs="0"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="email" type="xs:string"/>
			<xs:element name="active" type="xs:boolean"/>
			<xs:element name="dimension-entry" type="dimension-entry-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The dimension entry denoting this user. In other words, to create a dimension reference to this user, use this entry. Non-writable
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="dimensions" type="dimensions-distribution" minOccurs="0"/>
			<xs:element name="dimension-user-percentage" type="xs:decimal" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="accesses">
		<xs:sequence>
			<xs:element name="access" type="access" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="access">
		<xs:sequence>
			<xs:element name="type" type="access-type"/>
			<xs:element name="registration-user" type="user-reference" minOccurs="0"/>
			<xs:element name="registration-datetime" type="xs:dateTime" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="access-roles">
		<xs:sequence>
			<xs:element name="access-role" type="access-role" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="access-role">
		<xs:sequence>
			<xs:element name="id" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-invoices">
		<xs:sequence>
			<xs:element name="client-invoice" type="client-invoice" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:simpleType name="edi-period-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Row"/>
			<xs:enumeration value="Invoice"/>
			<xs:enumeration value="None"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="client-invoice-status-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="WrittenOffAndPaid"/>
			<xs:enumeration value="WrittenOff"/>
			<xs:enumeration value="Paid"/>
			<xs:enumeration value="Unpaid"/>
			<xs:enumeration value="Credited"/>
			<xs:enumeration value="ReservedAsUncertain"/>
			<xs:enumeration value="PartiallyPaid"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="client-invoice">
		<xs:sequence>

			<!-- The invoice's internal identifier in PE. Unique within a given company. Non-writable. -->
			<xs:element name="id" type="xs:int"/>
			<!-- The invoice's number, set when invoice is certified. Otherwise 0. Non-writable. -->
			<xs:element name="invoice-nr" type="xs:int"/>

			<!--
				Used when creating a credit invoice. Specify invoice number of debit invoice in order to create
				proper association. Required for all credit invoices.
			-->
			<xs:element name="debit-invoice-nr" type="xs:int" minOccurs="0"/>

			<!--
			Used when creating a credit invoice. If delete-row-reference-when-credit is set to true, credited time from timereporting can be invoiced again.
			-->
			<xs:element name="delete-row-reference-when-credit" type="xs:boolean" minOccurs="0"/>

			<!--
			Optional period type
			default is whatever se.kleer.accounting.core.edi.model.EdiPeriodType specifies as default
			-->

			<xs:element name="edi-period-type" type="edi-period-type" minOccurs="0"/>

			<!--
				List of invoices that was used to credit this invoice. Ignored when writing
			-->
			<xs:element name="credit-invoices" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="client-invoice" type="client-invoice-reference" minOccurs="0"
									maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!-- For an aggregated invoice, a list of aggregated invoices. Ignored when writing -->
			<xs:element name="aggregated-invoices" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="client-invoice" type="client-invoice-reference" minOccurs="0"
									maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="foreign-id" type="xs:string"/>

			<!-- Mandatory element, but can be empty string -->
			<xs:element name="po-nr" type="xs:string"/>
			<xs:element name="agreement-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="subscription-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="client-ref" type="client-reference"/>

			<!--
			End client if the invoice uses broker-client
			-->
			<xs:element name="end-client" type="client-reference" minOccurs="0"/>

			<!-- Optional. If not set, a template will be automatically assigned -->
			<xs:element name="client-invoice-template-ref" type="client-invoice-template-reference" minOccurs="0"/>

			<xs:element name="your-reference" type="xs:string"/>

			<!-- Using 0 will result in no reference being set -->
			<xs:element name="our-reference" type="user-reference"/>

			<!-- Using 0 will result in no reference being set -->
			<xs:element name="approver" type="user-reference" minOccurs="0"/>

			<xs:element name="invoice-address" type="address"/>
			<xs:element name="invoice-email" type="xs:string"/>
			<xs:element name="delivery-name" type="xs:string"/>
			<xs:element name="delivery-address" type="address"/>
			<xs:element name="delivery-email" type="xs:string"/>
			<xs:element name="invoice-date" type="xs:date"/>
			<xs:element name="due-date" type="xs:date"/>

			<!-- Mandatory element, but can be empty string -->
			<xs:element name="delivery-date" type="xs:date"/>

			<!-- Period used for accrual. -->
			<xs:element name="period" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="start-date" type="xs:date"/>
						<xs:element name="end-date" type="xs:date"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!-- In cent, excluding vat -->
			<xs:element name="amount" type="xs:long" minOccurs="0"/>

			<!-- In cent -->
			<xs:element name="vat" type="xs:long" minOccurs="0"/>

			<xs:element name="currency" type="xs:string"/>

			<!-- If not specified, the latest available currency rate will be used -->
			<xs:element name="currency-rate" type="xs:decimal" minOccurs="0"/>

			<!-- Whether this invoice has been certified or not. Read-only -->
			<xs:element name="certified" type="xs:boolean"/>
			<xs:element name="certified-date" type="xs:dateTime" minOccurs="0"/>

			<!-- Whether this invoice has been sent at least once or not. Read-only -->
			<xs:element name="sent" type="xs:boolean"/>

			<xs:element name="notes" type="xs:string" minOccurs="0"/>

			<!-- When creating, leave empty to use default delivery. When saving, leave empty to leave original value unchanged. -->
			<xs:element name="delivery-type" type="xs:string" minOccurs="0"/>

			<xs:element name="gln" type="xs:string" minOccurs="0"/>

			<!-- When creating, leave empty to use client vat-nr. When saving leave empty to leave original value unchanged -->
			<xs:element name="vat-nr" type="xs:string" minOccurs="0"/>

			<!--
				The ISO 3166-1 alpha-2 code for sales turnover for the client invoice
				When creating, leave empty to use client country code. When saving leave empty to leave original value unchanged
			-->
			<xs:element name="country-code" type="xs:string" minOccurs="0"/>

			<!-- Set when reading invoices created from client agreements. Ignored when creating/updating. -->
			<xs:element name="client-agreement-ref" type="client-agreement-reference" minOccurs="0"/>

			<!-- In cent, will be 0 for non-certified invoices. Read-only -->
			<xs:element name="remaining" type="xs:long"/>

			<!-- Computed payment/write-off status of the invoice. Read-only -->
			<xs:element name="status" type="client-invoice-status-type" minOccurs="0"/>

			<xs:element name="last-payment-date" type="xs:date" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The last date, if any, that this invoice had a payment registered.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<!-- A disabled invoice means it has been deleted by a user. -->
			<xs:element name="disabled" type="xs:boolean"/>
			<xs:element name="automatic-actions-disabled" type="xs:boolean" minOccurs="0"/>
			<xs:element name="automatic-actions-message" type="xs:string" minOccurs="0"/>

			<xs:element name="fields" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="field" type="field" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="approved" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="user" type="user-reference"/>
						<xs:element name="registration-date" type="xs:dateTime"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!-- How the invoice was delivered (Readonly) -->
			<xs:element name="invoice-deliveries" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="invoice-delivery" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="delivery-method" type="delivery-method-type"/>
									<xs:element name="registration-user" type="user-reference" minOccurs="0"/>
									<xs:element name="registration-datetime" type="xs:dateTime" minOccurs="0"/>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!--
				When saving/updating, do not include this element to "leave existing files as they are". If element
			 	is present, files will be replaced with content. Specifically, a <files>-element with zero files
			 	will delete any existing.
			 	-->
			<xs:element name="files" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" minOccurs="0" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="rows">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="row" type="client-invoice-row" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="reinvoicings" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="row" type="reinvoicing" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!--If the invoice is sent to factoring - Read only-->
			<xs:element name="factoring" type="xs:boolean" minOccurs="0"/>

			<xs:element name="self-invoice-references" type="supplier-invoice-relation" minOccurs="0" maxOccurs="0"/>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-invoice-row">
		<xs:sequence>

			<xs:element name="id" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique identifier for this row, read only value. Can be safely ignored
						when creating or updating client invoices.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="quantity" type="xs:decimal"/>

			<!-- In cent -->
			<xs:element name="price" type="xs:long"/>

			<!-- Overwritten everywhere except for when OSS rules apply -->
			<xs:element name="vat" type="xs:decimal"/>

			<xs:element name="product" type="product-reference"/>
			<xs:element name="unit" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>

			<!-- Deprecated when writing, always derived from product reference configuration -->
			<xs:element name="account-nr" type="xs:int"/>

			<!-- Deprecated - use dimension-entries instead - Will be removed in the future -->
			<xs:element name="project" type="project-reference" minOccurs="0"/>

			<xs:element name="dimensions" type="dimensions-distribution" minOccurs="0"/>

			<!-- Period used for accrual. -->
			<xs:element name="period" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="start-date" type="xs:date"/>
						<xs:element name="end-date" type="xs:date"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="delivery-date" type="xs:date" minOccurs="0"/>

			<xs:element name="discount" minOccurs="0">
				<xs:complexType>
					<xs:choice>
						<!-- In cent -->
						<xs:element name="absolute" type="xs:long"/>
						<xs:element name="percentage" type="xs:decimal"/>
					</xs:choice>
				</xs:complexType>
			</xs:element>

			<xs:element name="fields" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="field" type="field" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="accruals" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="accrual" type="accrual" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:simpleType name="reinvoicing-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="SupplierInvoice"/>
			<xs:enumeration value="ExpenseEntry"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="reinvoicing">
		<xs:sequence>

			<xs:element name="id" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique identifier for reinvocing
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="reinvoicing-type" type="reinvoicing-type" minOccurs="0"/>

			<xs:element name="supplier-invoice" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Id of the supplier invoice the reinvoicing is related to
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="expense-entry" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Id of the expense entry the reinvoicing is related to
					</xs:documentation>
				</xs:annotation>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:simpleType name="delivery-method-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Mail"/>
			<xs:enumeration value="Email"/>
			<xs:enumeration value="Manually"/>
			<xs:enumeration value="Svea"/>
			<xs:enumeration value="Efaktura"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="client-invoice-payment-writable">
		<xs:sequence>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="invoice-amount" type="xs:long">
				<xs:annotation>
					<xs:documentation>
						The amount in the invoice's currency that this payment represents. If the invoice's
						currency is the same as the company's accounting currency, this amount and
						accounting amount must always be equal.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="accounting-amount" type="xs:long">
				<xs:annotation>
					<xs:documentation>
						The accounting amount that this payment represents. If the invoice's
						currency is the same as the company's accounting currency, thus amount and
						invoice amount must be equal.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="transactions">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="transaction" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="account-nr" type="xs:int"/>
									<xs:element name="amount" type="xs:long"/>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="files">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" minOccurs="0" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue-ledger">
		<xs:sequence>
			<xs:element name="id" type="revenue-ledger-id"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="account-nr" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue-update">
		<xs:annotation>
			<xs:documentation>
				Used when updating an existing revenue. Provide a &lt;revenue-create&gt; as when creating, together with a message
				with the reason for this update.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="create" type="revenue-create"/>
			<xs:element name="message" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue-create">
		<xs:sequence>

			<xs:element name="debit-revenue" type="revenue-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If this revenue represents a credit for a prior created revenue, it must be referenced here. Negative revenues
						can not be created without referencing a debit.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="ledger" type="revenue-ledger-reference"/>

			<xs:element name="external-id" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						A unique identifier for this revenue.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="client" type="client-reference" minOccurs="0"/>
			<xs:element name="new-client" type="new-client" minOccurs="0"/>
			<xs:element name="country-code" type="xs:string"/>
			<xs:element name="transaction-date" type="xs:date"/>

			<xs:element name="row" minOccurs="0" maxOccurs="unbounded">
				<xs:complexType>
					<xs:sequence>

						<xs:element name="product" type="product-reference"/>

						<xs:element name="original-amount" type="revenue-original-amount"/>

						<xs:element name="accounting-amount" type="revenue-accounting-amount" minOccurs="0">
							<xs:annotation>
								<xs:documentation>
									If given, the exact accounting amounts that should be used. If not given, final values will be
									determined using the exchange rate for the given currency on the transaction date.
								</xs:documentation>
							</xs:annotation>
						</xs:element>

						<xs:element name="period" type="period" minOccurs="0">
							<xs:annotation>
								<xs:documentation>
									If not set, transaction date will be used.
								</xs:documentation>
							</xs:annotation>
						</xs:element>

						<xs:element name="dimensions" type="dimensions-distribution" minOccurs="0"/>

					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="file" type="file" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						At least one file must be given, to use as basis for the accounting.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue">
		<xs:sequence>

			<xs:element name="id" type="revenue-id"/>
			<xs:element name="ledger" type="revenue-ledger-reference"/>
			<xs:element name="external-id" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						A unique identifier for this revenue.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="revision" type="xs:int" minOccurs="0"/>
			<xs:element name="client" type="client-reference" minOccurs="0"/>
			<xs:element name="country-code" type="xs:string"/>
			<xs:element name="transaction-date" type="xs:date"/>
			<xs:element name="remaining-accounting-amount" type="xs:long"/>

			<xs:element name="row" minOccurs="0" maxOccurs="unbounded">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="id" type="xs:int"/>
						<xs:element name="product" type="product-reference"/>
						<xs:element name="original-amount" type="revenue-original-amount"/>
						<xs:element name="accounting-amount" type="revenue-accounting-amount"/>
						<xs:element name="period" type="period"/>
						<xs:element name="dimensions" type="dimensions-distribution"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue-original-amount">
		<xs:sequence>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="vat" type="xs:long"/>
			<xs:element name="currency" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue-accounting-amount">
		<xs:sequence>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="vat" type="xs:long"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="supplier-invoices">
		<xs:sequence>
			<xs:element name="supplier-invoice" type="supplier-invoice" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:element name="supplier-invoice-payee">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="supplier-invoice-payee"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:element name="client-invoice-relation">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="client-invoice-relation"/>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>

	<xs:complexType name="supplier-invoice-writeable">
		<xs:sequence>

			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="supplier" type="supplier-reference"/>

			<xs:element name="bank-account" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The bank account that should be used as debtor for this supplier invoice. If none is given,
						a suitable bank account will automatically be chosen. This is an optional field only
						relevant if payments are performed from different bank accounts. If unsure, please leave
						empty.
					</xs:documentation>
				</xs:annotation>
				<xs:complexType>
					<xs:choice>
						<xs:element name="bankgiro" type="xs:string">
							<xs:annotation>
								<xs:documentation>
									Select bank account associated with the given bankgiro.
								</xs:documentation>
							</xs:annotation>
						</xs:element>
						<xs:element name="reference" type="bank-account-reference">
							<xs:annotation>
								<xs:documentation>
									Select bank account with the given identifier.
								</xs:documentation>
							</xs:annotation>
						</xs:element>
					</xs:choice>
				</xs:complexType>
			</xs:element>

			<xs:element name="your-reference" type="user-reference" minOccurs="0"/>
			<xs:element name="our-reference" type="xs:string"/>

			<xs:element name="deposit-account" type="supplier-invoice-payee"/>
			<xs:element name="accounting-date" type="xs:date" minOccurs="0"/>
			<xs:element name="invoice-date" type="xs:date"/>
			<xs:element name="due-date" type="xs:date"/>
			<xs:element name="payment-date" type="xs:date"/>
			<!-- In cent -->
			<xs:element name="amount" type="xs:long"/>
			<!-- In cent -->
			<xs:element name="vat" type="xs:long"/>
			<xs:element name="currency" type="xs:string"/>
			<xs:element name="currency-rate" type="xs:decimal"/>
			<xs:element name="po-nr" type="xs:string"/>
			<xs:element name="reference-nr" type="xs:string"/>
			<xs:element name="ocr" type="xs:string"/>
			<xs:element name="reminder-type" type="supplier-invoice-reminder-type" minOccurs="0"/>

			<!-- Only PDF files are currently accepted -->
			<xs:element name="files">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="accounts">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="account" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="account-nr" type="xs:int"/>

									<xs:element name="vat-code" type="vat-code-type" nillable="true" minOccurs="0">
										<xs:annotation>
											<xs:documentation>
												Vat code used for this account. If omitted, default vat code
												from account will be used. If null this account will not have vat code.
											</xs:documentation>
										</xs:annotation>
									</xs:element>

									<xs:element name="amount" type="xs:long"/>

									<!-- Deprecated - use dimension-entries instead - Will be removed in the future -->
									<xs:element name="project" type="project-reference" minOccurs="0"/>

									<!-- May only be used for result accounts -->
									<xs:element name="dimension-entries" minOccurs="0">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="dimension-entry" type="dimension-entry-reference"
															minOccurs="0" maxOccurs="unbounded"/>
											</xs:sequence>
										</xs:complexType>
									</xs:element>

									<!-- Period used for accrual, may only be used for result accounts -->
									<xs:element name="period" minOccurs="0">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="start-date" type="xs:date"/>
												<xs:element name="end-date" type="xs:date"/>
											</xs:sequence>
										</xs:complexType>
									</xs:element>

								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="client-invoice-relations" type="client-invoice-relation" minOccurs="0"/>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="supplier-invoice">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="supplier-ref" type="supplier-reference"/>
			<xs:element name="bank-account-ref" type="bank-account-reference" minOccurs="0"/>
			<xs:element name="your-reference" type="user-reference" minOccurs="0"/>
			<xs:element name="our-reference" type="xs:string"/>
			<xs:element name="deposit-account-type" type="supplier-invoice-deposit-account-type"/>
			<xs:element name="deposit-account-nr" type="xs:string"/>
			<xs:element name="accounting-date" type="xs:date"/>
			<xs:element name="invoice-date" type="xs:date"/>
			<xs:element name="due-date" type="xs:date"/>
			<!-- In cent -->
			<xs:element name="amount" type="xs:long"/>
			<!-- In cent -->
			<xs:element name="vat" type="xs:long"/>
			<xs:element name="currency" type="xs:string"/>
			<xs:element name="currency-rate" type="xs:decimal"/>
			<xs:element name="po-nr" type="xs:string"/>
			<xs:element name="reference-nr" type="xs:string"/>
			<xs:element name="ocr" type="xs:string"/>
			<xs:element name="payment-date" type="xs:date"/>

			<!-- Is only set if the invoice has approvals -->
			<xs:element name="supplier-invoice-approvals" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="supplier-invoice-approval" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="approval-user" type="user-reference"/>
									<xs:element name="approval-date" type="xs:dateTime"/>
									<xs:element name="approval-note" type="xs:string" minOccurs="0"/>
									<xs:element name="approval-type" type="supplier-invoice-approval-type"/>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="certified" type="xs:boolean"/>
			<xs:element name="reminder-type" type="supplier-invoice-reminder-type"/>
			<!-- In cent -->
			<xs:element name="remaining" type="xs:long"/>
			<xs:element name="supplier-invoice-payments">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="supplier-invoice-payment" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="id" type="xs:int"/>
									<xs:element name="date" type="xs:date"/>
									<xs:element name="amount" type="xs:long"/>
									<xs:element name="accounting-amount" type="xs:long"/>
									<xs:element name="payee-type" type="supplier-invoice-payee"/>
									<xs:element name="reference-nr" type="xs:string" minOccurs="0"/>
									<xs:element name="ocr" type="xs:string" minOccurs="0"/>
									<xs:element name="status" maxOccurs="unbounded">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="id" type="xs:int"/>
												<xs:element name="type" type="supplier-invoice-payment-status-type"/>
												<xs:element name="date" type="xs:date"/>
												<xs:element name="message" type="xs:string" minOccurs="0"/>
											</xs:sequence>
										</xs:complexType>
									</xs:element>
									<xs:element name="registration-user" type="user-reference"/>
									<xs:element name="registration-date" type="xs:dateTime"/>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="accounts">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="account" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>

									<xs:element name="id" type="xs:int" minOccurs="0">
										<xs:annotation>
											<xs:documentation>
												Unique identifier for this account, read only value. Can be safely
												ignored
												when creating or updating supplier invoices.
											</xs:documentation>
										</xs:annotation>
									</xs:element>

									<xs:element name="account-nr" type="xs:int"/>
									<xs:element name="vat-code" type="vat-code-type" nillable="true"/>
									<xs:element name="amount" type="xs:long"/>
									<xs:element name="dimension-entries" minOccurs="0">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="dimension-entry" type="dimension-entry-reference"
															minOccurs="0" maxOccurs="unbounded"/>
											</xs:sequence>
										</xs:complexType>
									</xs:element>
									<xs:element name="period" minOccurs="0">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="start-date" type="xs:date"/>
												<xs:element name="end-date" type="xs:date"/>
											</xs:sequence>
										</xs:complexType>
									</xs:element>

								</xs:sequence>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<!-- ISO 3166-1 alpha-2 code -->
			<xs:element name="country-code" type="xs:string" minOccurs="0"/>

			<xs:element name="self-invoice-references" type="client-invoice-relation"/>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="products">
		<xs:sequence>
			<xs:element name="product" type="product" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="product">
		<xs:sequence>

			<xs:element name="id" type="xs:int"/>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>

			<xs:element name="type" type="purchase-type" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Optional when creating/updating. Default value will be used if not set
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="unit" type="xs:string"/>
			<xs:element name="price" type="xs:long"/>

			<xs:element name="ean" type="xs:long">
				<xs:annotation>
					<xs:documentation>
						Deprecated and no longer used
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="dimension-entries" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="dimension-entry" type="dimension-entry-reference"
									minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="account-nr" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Optional when creating/updating. Default value will be used if not set
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="vat-percentage" type="xs:decimal" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Vat percentage used for domestic sales using this product.
						Optional when creating/updating. Default value will be used if not set
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="accounts" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Deprecated, se will still be used to set account-nr, if it is not set.
						For backwards compatibility.

						When reading all elements will have value of account-nr.

						Optional when creating/updating. Default values will be used if not set.
					</xs:documentation>
				</xs:annotation>
				<xs:complexType>
					<xs:sequence>
						<!-- Optional when creating/updating. Default value will be used if not set -->
						<xs:element name="se" type="xs:int" minOccurs="0"/>
						<!-- Optional when creating/updating. Default value will be used if not set -->
						<xs:element name="eu" type="xs:int" minOccurs="0"/>
						<!-- Optional when creating/updating. Default value will be used if not set -->
						<xs:element name="export" type="xs:int" minOccurs="0"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-agreements">
		<xs:sequence>
			<xs:element name="client-agreement" type="client-agreement" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-agreement">
		<xs:sequence>

			<!-- The identifier for this agreement -->
			<xs:element name="id" type="xs:int"/>

			<xs:element name="foreign-id" type="xs:string"/>

			<!-- The revision of the agreement -->
			<xs:element name="revision-nr" type="xs:int"/>

			<!-- The client associated with this agreement -->
			<xs:element name="client-ref" type="client-reference"/>

			<!-- The description of the agreement -->
			<xs:element name="description" type="xs:string"/>

			<xs:element name="start-date" type="xs:date" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						This field is deprecated and is no longer used. When creating or updating an agreement, this
						field is ignored. When reading an agreement, its value will always be identical to
						start-invoice-date.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<!--
							  The date from which invoices should start to be generated. Used mainly for agreements that were
							  started before being created in PE.

							  -->
			<xs:element name="start-invoice-date" type="xs:date"/>

			<!-- The next invoice date  -->
			<xs:element name="next-invoice-date" type="xs:date" nillable="true"/>

			<!--
												 The agreement's end date.
											 -->
			<xs:element name="end-date" type="xs:date" nillable="true"/>

			<!--
							Date for reminder of agreements renewal
							-->
			<xs:element name="renewal-notification-date" type="xs:date" minOccurs="0"/>

			<xs:element name="your-reference" type="xs:string"/>
			<xs:element name="our-reference" type="user-reference" nillable="true"/>
			<xs:element name="approver" type="user-reference" nillable="true"/>

			<xs:element name="currency" type="xs:string"/>

			<xs:element name="payment-days" type="xs:int"/>

			<!--
											 How often the client should be invoiced in months. Typical values are
											 1, 3, 6 and 12
											 -->
			<xs:element name="invoice-interval-months" type="xs:int"/>

			<!-- Invoice strategy to use -->
			<xs:element name="invoice-day" type="invoice-day"/>

			<xs:element name="po-nr" type="xs:string"/>

			<xs:element name="agreement-nr" type="xs:string"/>

			<xs:element name="subscription-nr" type="xs:string"/>

			<!-- Accrual configuration, if applicable. Optional. -->
			<xs:element name="accrual-configuration" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="accrual-account-nr" type="xs:int"/>
						<xs:element name="revenue-account-nr" type="xs:int"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!-- Internal notes for the agreement. Optional -->
			<xs:element name="notes" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Optional when creating/updating. Empty value will be used if not set
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<!-- True if this agreement has been deleted, otherwise false -->
			<xs:element name="deleted" type="xs:boolean"/>

			<xs:element name="fields" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="field" type="field" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!-- Rows that will only appear on the first invoice -->
			<xs:element name="first-invoice-rows">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="row" type="client-agreement-row" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<!-- Rows that will appear on every invoice -->
			<xs:element name="recurring-rows">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="row" type="client-agreement-row" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="registration-user" type="user-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Set when reading agreements. Ignored when creating/updating
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="registration-date" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Set when reading agreements. Ignored when creating/updating
					</xs:documentation>
				</xs:annotation>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-agreement-row">
		<xs:sequence>
			<xs:element name="quantity" type="xs:decimal"/>
			<!-- In cent -->
			<xs:element name="price" type="xs:long"/>
			<xs:element name="product" type="product-reference" minOccurs="0"/>
			<xs:element name="unit" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="discount" minOccurs="0">
				<xs:complexType>
					<xs:choice>
						<!-- In cent -->
						<xs:element name="absolute" type="xs:long"/>
						<xs:element name="percentage" type="xs:decimal"/>
					</xs:choice>
				</xs:complexType>
			</xs:element>
			<xs:element name="fields" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="field" type="field" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="dimensions" type="dimensions-distribution" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="activity-readables">
		<xs:sequence>
			<xs:element name="activity-readable" type="activity-readable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="internal-hourly-cost-readables">
		<xs:sequence>
			<xs:element name="internal-hourly-cost-readable" type="internal-hourly-cost-readable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="activity-readable">
		<xs:sequence>
			<xs:element name="id" type="activity-reference"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="price" type="xs:long" minOccurs="0"/>
			<xs:element name="mandatory-child-when-reporting" type="xs:boolean"/>
			<xs:element name="invoice-product" type="product-reference" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="internal-hourly-cost-readable">
		<xs:sequence>
			<xs:element name="activity" type="activity-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If activity id is absent, it is the users internal hourly cost for all unspecified activities
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="start-date" type="xs:date"/>
			<xs:element name="price" type="xs:long"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="internal-hourly-cost-writable">
		<xs:sequence>
			<xs:element name="activity" type="activity-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If activity id is absent, it is the users internal hourly cost for all unspecified activities
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="start-date" type="xs:date"/>
			<xs:element name="price" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If price is absent, use activity default price
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="internal-hourly-cost-writables">
		<xs:sequence>
			<xs:element name="internal-hourly-cost-writable" type="internal-hourly-cost-writable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="event-readables">
		<xs:sequence>
			<xs:element name="event-readable" type="event-readable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="event-readable">
		<xs:sequence>
			<xs:element name="id" type="event-reference"/>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="user" type="user-reference"/>
			<xs:element name="activity" type="activity-reference"/>
			<xs:element name="client-project" type="client-project-reference" minOccurs="0"/>
			<xs:element name="child" type="xs:string" minOccurs="0"/>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="hours" type="xs:decimal"/>
			<xs:element name="comment" type="xs:string"/>
			<xs:element name="internal-comment" type="xs:string"/>
			<xs:element name="invoiceable" type="xs:boolean"/>
			<xs:element name="invoiced-hours" type="xs:decimal"/>
			<xs:element name="invoiced-price" type="xs:long"/>

			<!-- Deprecated - use status instead - Will be removed in the future -->
			<xs:element name="approved" type="xs:boolean"/>

			<xs:element name="status" type="event-status"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="event-writable">
		<xs:sequence>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="user" type="user-reference"/>
			<xs:element name="activity" type="activity-reference"/>
			<xs:element name="client-project" type="client-project-reference" minOccurs="0"/>
			<xs:element name="child" type="xs:string" minOccurs="0"/>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="hours" type="xs:decimal"/>
			<xs:element name="comment" type="xs:string"/>
			<xs:element name="internal-comment" type="xs:string" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="certify-events-request">
		<xs:sequence>
			<xs:element name="user-id" type="user-reference"/>
			<xs:element name="start-date" type="xs:date"/>
			<xs:element name="end-date" type="xs:date"/>
			<xs:element name="client-project-id" type="client-project-reference" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="approve-events-request">
		<xs:sequence>
			<xs:element name="user-id" type="user-reference"/>
			<xs:element name="start-date" type="xs:date"/>
			<xs:element name="end-date" type="xs:date"/>
			<xs:element name="client-project-id" type="client-project-reference" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="unlock-events-request">
		<xs:sequence>
			<xs:element name="user-id" type="user-reference"/>
			<xs:element name="start-date" type="xs:date"/>
			<xs:element name="end-date" type="xs:date"/>
			<xs:element name="client-project-id" type="client-project-reference" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="supplier-invoice-approval">
		<xs:annotation>
			<xs:documentation>
				Can be used to approve or deny the invoice, with optional comment.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="approval-user" type="user-reference"/>
			<xs:element name="approval-note" type="xs:string" minOccurs="0"/>
			<xs:element name="approval-type" type="supplier-invoice-approval-type">
				<xs:annotation>
					<xs:documentation>
						The type of approval can either be "APPROVAL" "DENIAL" or "TIMEOUT".
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="event-restriction-readables">
		<xs:sequence>
			<xs:element name="event-restriction-readable" type="event-restriction-readable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="event-restriction-readable">
		<xs:sequence>
			<xs:element name="status" type="event-restriction-status"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-readables">
		<xs:sequence>
			<xs:element name="client-project-readable" type="client-project-readable" minOccurs="0"
						maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-readable">
		<xs:sequence>
			<xs:element name="id" type="client-project-reference"/>
			<xs:element name="client" type="client-reference" minOccurs="0"/>
			<xs:element name="broker-client" type="client-reference" minOccurs="0"/>
			<xs:element name="fixed-price" type="xs:boolean"/>
			<xs:element name="number" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="currency-type" type="xs:string"/>
			<xs:element name="active" type="xs:boolean"/>
			<xs:element name="your-reference" type="xs:string" minOccurs="0"/>
			<xs:element name="our-reference" type="user-reference" minOccurs="0"/>
			<xs:element name="delivery-type" type="delivery-method-type" minOccurs="0"/>
			<xs:element name="email" type="xs:string" minOccurs="0"/>
			<xs:element name="comment" type="xs:string"/>
			<xs:element name="payment-days" type="xs:integer" minOccurs="0"/>
			<xs:element name="po-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="budget-hours" type="xs:decimal"/>
			<xs:element name="budget-amount" type="xs:long"/>
			<xs:element name="incoming-invoiced-amount" type="xs:long"/>
			<xs:element name="incoming-invoiced-vat-amount" type="xs:long"/>
			<xs:element name="all-activities" type="xs:boolean"/>
			<xs:element name="activity" type="client-project-activity" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="all-users" type="xs:boolean"/>
			<xs:element name="user" type="client-project-user" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="leads" type="lead" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="fixed-price-planned-invoice" type="fixed-price-planned-invoice" minOccurs="0"
						maxOccurs="unbounded"/>
			<xs:element name="write-off" type="client-project-write-off" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="dimension-entry" type="dimension-entry-reference" minOccurs="0"/>
			<xs:element name="status" type="client-project-status-type"/>
			<xs:element name="opening-date" type="xs:date" minOccurs="0"/>
			<xs:element name="closing-date" type="xs:date" minOccurs="0"/>
			<xs:element name="dimensions" type="dimensions-distribution" minOccurs="0"/>
			<xs:element name="default-notes" type="xs:string" minOccurs="0"/>
			<xs:element name="fields" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="field" type="field" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="updated-user-key" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The key (UUID) of the user who last updated the project. Non-writable.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="updated-date" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date and time when the project was last updated. Non-writable.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="group-project" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						True when this project is a group project (koncernprojekt). A group project is
						replicated into the subsidiary companies that its members take part from, and the
						company must have the group project setting active.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="internal-invoicing-enabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						True when the group self-billing flow is enabled for this project. It is a modifier on a
						group project: it can only be turned on for a project that is, or is becoming, a group
						project, on a company that has the setting enabled. It is not the group internal invoice
						price, which is read and written through group-internal-price.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="sub-project" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						True when this project is the replicated copy held by a subsidiary company. Such a copy
						is maintained from its master project and is read-only: attempts to change it through this
						API — updating the project, its users or its activities, and opening or closing it — are
						rejected. The exception is the subsidiary's own client-invoice prices (client-project
						prices), which belong to the copy and can still be set.

						Saving the master project overwrites the fields it mirrors, among them name, number,
						comment, currency, budget amount, opening and closing date, the member list and
						internal-invoicing-enabled. Fields outside that set, budget hours among them, are copied
						once when the copy is created and are not maintained afterwards.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-writeable">
		<xs:sequence>
			<xs:element name="client" type="client-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Can only be set when creating new project
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="broker-client" type="client-reference" minOccurs="0" nillable="true">
				<xs:annotation>
					<xs:documentation>
						Optional client to use as client instead of "normal" client when creating new client invoices
						from the project. Omitting this value will set it to default when creating,
						and leave it unchanged when updating. Setting to null explicitely clears the value.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="fixed-price" type="xs:boolean">
				<xs:annotation>
					<xs:documentation>
						Can only be set when creating new project
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="number" type="xs:string"/>
			<xs:element name="name" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						Can only be set when creating new project
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="currency-type" type="xs:string" minOccurs="0"/>
			<xs:element name="your-reference" type="xs:string" minOccurs="0"/>
			<xs:element name="our-reference" type="user-reference" minOccurs="0"/>
			<xs:element name="delivery-type" type="delivery-method-type" minOccurs="0"/>
			<xs:element name="comment" type="xs:string"/>
			<xs:element name="payment-days" type="xs:integer" minOccurs="0"/>
			<xs:element name="po-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="budget-hours" type="xs:decimal"/>
			<xs:element name="budget-amount" type="xs:long"/>
			<xs:element name="incoming-invoiced-amount" type="xs:long"/>
			<xs:element name="incoming-invoiced-vat-amount" type="xs:long"/>
			<xs:element name="all-activities" type="xs:boolean"/>
			<xs:element name="activity" type="client-project-activity" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Replaces the project's activities. Not allowed for companies with Project V2, where the
						project's activities are maintained through the activities endpoint instead.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="all-users" type="xs:boolean"/>
			<xs:element name="user" type="client-project-user" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Replaces the project's members. For companies with Project V2 this only applies when
						creating a project: an update leaves the members unchanged, and they are maintained
						through the users endpoint instead. A member cannot carry activities for companies with
						Project V2, neither when creating nor when updating.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="leads" type="lead" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="fixed-price-planned-invoice" type="fixed-price-planned-invoice" minOccurs="0"
						maxOccurs="unbounded"/>
			<xs:element name="opening-date" type="xs:date" minOccurs="0"/>
			<xs:element name="closing-date" type="xs:date" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Will not set status of project to closed, doing so is another operation.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="default-notes" type="xs:string" minOccurs="0"/>
			<xs:element name="dimension-entries" type="dimensions-distribution" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Omitting this element will leave dimension-entries unchanged when updating
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="fields" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="field" type="field" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="group-project" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Makes the project a group project (koncernprojekt), which replicates it into the
						subsidiary companies its members take part from. Requires the company to have group
						projects active, and cannot be combined with fixed-price.

						Absent leaves the project as it is. Send it only when the value should change: sending
						false on a project that has already been replicated is rejected, because the copies the
						subsidiaries hold would stop being updated and nothing resyncs them afterwards.

						Replication needs a member taking part from another company in the group. Setting this
						alone leaves the project without subsidiary copies, and only activities whose base
						activity is a group activity are replicated.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="internal-invoicing-enabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Enables the group self-billing flow for this project. It can only be turned on together
						with, or on, a group project, and only for a company that has the setting enabled, and it
						must be turned off before the project stops being a group project.

						Absent leaves the project as it is. This is not the group internal invoice price, which is
						read and written through group-internal-price.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="dimensions-distribution">
		<xs:sequence>
			<xs:element name="dimension-entry" minOccurs="0" maxOccurs="unbounded">
				<xs:complexType>
					<xs:sequence>

						<xs:element name="id" type="xs:int"/>

						<!-- If not specified, defaults to 1 (100%) -->
						<xs:element name="percentage" type="xs:decimal" minOccurs="0"/>

					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="activity-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-activity">
		<xs:sequence>
			<xs:element name="activity" type="activity-reference"/>
			<xs:element name="price" type="xs:long" minOccurs="0"/>
			<xs:element name="supplier-price" type="xs:long" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-user-activity">
		<xs:sequence>
			<xs:element name="activity" type="activity-reference"/>
			<xs:element name="price" type="xs:long" minOccurs="0"/>
			<xs:element name="supplier-price" type="xs:long" minOccurs="0"/>
			<xs:element name="dimension-user-percentage" type="xs:decimal" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-user">
		<xs:sequence>
			<xs:element name="user" type="user-reference"/>
			<xs:element name="activity" type="client-project-user-activity" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="origin-company" type="company-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The company this member takes part from. Absent leaves an existing member as it is and
						places a new one in the project own company, which is the only company a member can take
						part from on a project that is not a group project.

						On a group project the set of subsidiary companies the project is replicated to is
						derived from the origin companies of its members, so a member taking part from another
						company in the group is what makes replication happen. Setting group-project without any
						such member leaves the project without subsidiary copies. The company must be one the
						project company shares a group with, and the user must have an active membership in it.
						This is checked when the member is added or the origin company changes, not on a member
						that is already taking part from it.

						Project leaders carry no origin company here: one supplied through this API always takes
						part from the project own company, and one taking part from another company is reported
						without that origin.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<!-- ProjectV2 read types -->

	<xs:complexType name="company-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-activity-price">
		<xs:sequence>
			<xs:element name="price" type="xs:long"/>
			<xs:element name="valid-from" type="xs:date"/>
			<xs:element name="type" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						One of Client, Supplier, Internal or SalaryBasis. Note that Internal is the
						project's own internal price. It is NOT the group's internal invoice price used
						when a master company invoices its subsidiaries for work on a group project —
						that price is per subsidiary and is read and written through group-internal-price.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="group-internal-price">
		<xs:annotation>
			<xs:documentation>
				The group's internal invoice price for one subsidiary company, effective from valid-from.
				This is what the subsidiary invoices the master for work on a group project.

				It is a per-subsidiary OVERRIDE, not a separate kind of price. Where no override exists for
				a subsidiary, that same invoiced price comes from the master activity's own price of type
				"Internal" if one is set, and from its "Client" price otherwise. So setting type=Internal on
				client-project-activity-price does affect what subsidiaries are invoiced — for every
				subsidiary that has no override here. Setting it does not change what a subsidiary with an
				override is invoiced, and reading it does not tell you the overridden value.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="subsidiary-company" type="company-reference"/>
			<xs:element name="price" type="xs:long"/>
			<xs:element name="valid-from" type="xs:date"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-activity-v2">
		<xs:sequence>
			<xs:element name="activity" type="activity-reference"/>
			<xs:element name="key" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string" minOccurs="0"/>
			<xs:element name="invoice-description" type="xs:string" minOccurs="0"/>
			<xs:element name="project-specific" type="xs:boolean"/>
			<xs:element name="payroll-cost-dimension-strategy" type="xs:string" minOccurs="0"/>
			<xs:element name="price" type="client-project-activity-price" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="group-internal-price" type="group-internal-price" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						The group's per-subsidiary internal invoice prices for this activity, for every
						subsidiary currently in the project, including historical and future-dated rows. A
						stored price whose subsidiary has since left the project is not reported, because the
						company it belongs to can no longer be named in the response.

						Only populated when reading a single project (GET /client-project/{clientProjectId})
						that is the master project of a group project in a company with cross-company projects
						active, and only for a caller with project read access; omitted from list responses
						and for all other projects. Note the consequence of that last condition: absence of
						this element means "not visible to you" as well as "none set", so do not read an empty
						result as proof that no internal invoice price exists.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-user-activity-v2">
		<xs:sequence>
			<xs:element name="key" type="xs:string"/>
			<xs:element name="project-activity-key" type="xs:string"/>
			<xs:element name="dimension-user-percentage" type="xs:decimal" minOccurs="0"/>
			<xs:element name="price" type="client-project-activity-price" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-user-v2">
		<xs:sequence>
			<xs:element name="user" type="user-reference"/>
			<xs:element name="activity-v2" type="client-project-user-activity-v2" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="origin-company" type="company-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The company this member takes part from. Absent leaves an existing member as it is and
						places a new one in the project own company, which is the only company a member can take
						part from on a project that is not a group project.

						On a group project the set of subsidiary companies the project is replicated to is
						derived from the origin companies of its members, so a member taking part from another
						company in the group is what makes replication happen. Setting group-project without any
						such member leaves the project without subsidiary copies. The company must be one the
						project company shares a group with, and the user must have an active membership in it.
						This is checked when the member is added or the origin company changes, not on a member
						that is already taking part from it.

						Project leaders carry no origin company here: one supplied through this API always takes
						part from the project own company, and one taking part from another company is reported
						without that origin.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-readables-v2">
		<xs:sequence>
			<xs:element name="client-project-readable-v2" type="client-project-readable-v2" minOccurs="0"
						maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-readable-v2">
		<xs:sequence>
			<xs:element name="id" type="client-project-reference"/>
			<xs:element name="client" type="client-reference" minOccurs="0"/>
			<xs:element name="broker-client" type="client-reference" minOccurs="0"/>
			<xs:element name="fixed-price" type="xs:boolean"/>
			<xs:element name="number" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="currency-type" type="xs:string"/>
			<xs:element name="active" type="xs:boolean"/>
			<xs:element name="your-reference" type="xs:string" minOccurs="0"/>
			<xs:element name="our-reference" type="user-reference" minOccurs="0"/>
			<xs:element name="delivery-type" type="delivery-method-type" minOccurs="0"/>
			<xs:element name="email" type="xs:string" minOccurs="0"/>
			<xs:element name="comment" type="xs:string"/>
			<xs:element name="payment-days" type="xs:integer" minOccurs="0"/>
			<xs:element name="po-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="budget-hours" type="xs:decimal"/>
			<xs:element name="budget-amount" type="xs:long"/>
			<xs:element name="incoming-invoiced-amount" type="xs:long"/>
			<xs:element name="incoming-invoiced-vat-amount" type="xs:long"/>
			<xs:element name="activity-v2" type="client-project-activity-v2" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="user-v2" type="client-project-user-v2" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="leads" type="lead" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="fixed-price-planned-invoice" type="fixed-price-planned-invoice" minOccurs="0"
						maxOccurs="unbounded"/>
			<xs:element name="write-off" type="client-project-write-off" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="dimension-entry" type="dimension-entry-reference" minOccurs="0"/>
			<xs:element name="status" type="client-project-status-type"/>
			<xs:element name="opening-date" type="xs:date" minOccurs="0"/>
			<xs:element name="closing-date" type="xs:date" minOccurs="0"/>
			<xs:element name="dimensions" type="dimensions-distribution" minOccurs="0"/>
			<xs:element name="default-notes" type="xs:string" minOccurs="0"/>
			<xs:element name="fields" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="field" type="field" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="updated-user-key" type="xs:string" minOccurs="0"/>
			<xs:element name="updated-date" type="xs:dateTime" minOccurs="0"/>
			<xs:element name="group-project" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						True when this project is a group project (koncernprojekt). A group project is
						replicated into the subsidiary companies that its members take part from, and the
						company must have the group project setting active.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="internal-invoicing-enabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						True when the group self-billing flow is enabled for this project. It is a modifier on a
						group project: it can only be turned on for a project that is, or is becoming, a group
						project, on a company that has the setting enabled. It is not the group internal invoice
						price, which is read and written through group-internal-price.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="sub-project" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						True when this project is the replicated copy held by a subsidiary company. Such a copy
						is maintained from its master project and is read-only: attempts to change it through this
						API — updating the project, its users or its activities, and opening or closing it — are
						rejected. The exception is the subsidiary's own client-invoice prices (client-project
						prices), which belong to the copy and can still be set.

						Saving the master project overwrites the fields it mirrors, among them name, number,
						comment, currency, budget amount, opening and closing date, the member list and
						internal-invoicing-enabled. Fields outside that set, budget hours among them, are copied
						once when the copy is created and are not maintained afterwards.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<!-- ProjectV2 write types -->

	<xs:complexType name="client-project-user-activity-v2-writeable">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="dimension-user-percentage" type="xs:decimal" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-activity-v2-writeable">
		<xs:sequence>
			<xs:element name="key" type="xs:string" minOccurs="0"/>
			<xs:element name="activity" type="activity-reference"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string" minOccurs="0"/>
			<xs:element name="invoice-description" type="xs:string" minOccurs="0"/>
			<xs:element name="payroll-cost-dimension-strategy" type="xs:string" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-user-v2-writeable">
		<xs:sequence>
			<xs:element name="user" type="user-reference"/>
			<xs:element name="activity" type="client-project-user-activity-v2-writeable" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="origin-company" type="company-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The company this member takes part from. Absent leaves an existing member as it is and
						places a new one in the project own company.

						On a group project this is what decides which subsidiaries the project is replicated to.
						The company must be one the project company shares a group with, and the user must have an
						active membership in it; this is checked when the member is added or the origin company
						changes, not on a member that is already taking part from it. Sending a different
						origin-company for a user who already takes part moves that membership.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-activities-v2-writeable">
		<xs:sequence>
			<xs:element name="activity" type="client-project-activity-v2-writeable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-users-v2-writeable">
		<xs:sequence>
			<xs:element name="user" type="client-project-user-v2-writeable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<!-- ProjectV2 price write types -->

	<xs:complexType name="client-project-activity-price-writeable">
		<xs:sequence>
			<xs:element name="key" type="xs:string"/>
			<xs:element name="price" type="xs:long"/>
			<xs:element name="valid-from" type="xs:date"/>
			<xs:element name="type" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						One of Client, Supplier, Internal or SalaryBasis. Note that Internal sets the
						project's own internal price. It does NOT set the group's internal invoice price
						used when a master company invoices its subsidiaries for work on a group project —
						use activity-group-internal-price for that.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-user-activity-price-writeable">
		<xs:sequence>
			<xs:element name="key" type="xs:string"/>
			<xs:element name="user" type="user-reference"/>
			<xs:element name="price" type="xs:long"/>
			<xs:element name="valid-from" type="xs:date"/>
			<xs:element name="type" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						One of Client, Supplier, Internal or SalaryBasis. As for activity-price, Internal
						is the project's own internal price and not the group's internal invoice price.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-activity-group-internal-price-writeable">
		<xs:annotation>
			<xs:documentation>
				The group's per-subsidiary internal invoice prices for one project activity, identified by
				its activity key. May only be sent by the master company for the master project of a group
				project in a company with cross-company projects active; any other caller is rejected.

				By default only the subsidiaries named in the payload are touched, and nothing is deleted.
				Activities not listed are left untouched either way.

				Set replace-all="true" to make the payload the AUTHORITATIVE SET for the activity instead —
				the behaviour the price dialog has, which is safe there because the dialog always renders and
				resends every subsidiary. Then a subsidiary of the project without an entry dated today or
				earlier has EVERY row dated today or earlier removed — its whole price history, not only the
				price in force — and falls back to the price described on group-internal-price. Future-dated
				rows are never removed by omission.

				Deleting history changes past billing, not only future billing: work is priced as of the
				date it was reported, so removing a row that was in force in March changes what March work
				still to be invoiced costs. That is why it is opt-in here: an integration sending a partial
				set has no way to know what it removed.

				Each entry upserts on (activity, subsidiary, valid-from). A future-dated entry replaces any
				existing future-dated price for that subsidiary, because a subsidiary can have at most one
				future price per activity.

				Under replace-all, note what this means for scheduling, because it is the case most easily
				got wrong: an entry dated in the future does not count as a price for today. Scheduling a
				rise for one subsidiary by sending only that one future-dated entry therefore removes the
				current price of EVERY subsidiary on the activity, including the one being scheduled, until
				the new date arrives. To schedule a change and keep today's prices, send each subsidiary's current entry
				alongside the future one. The price dialog does this for you; over the API it is explicit.

				The mirror image is worth knowing too: an entry dated in the past DOES count as a price for
				today, so it protects the subsidiary from clearing — but it does not change what is charged
				today if a later row already exists. Such a call is accepted and changes nothing visible.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="key" type="xs:string"/>
			<xs:element name="group-internal-price" type="group-internal-price" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="replace-all" type="xs:boolean"/>
	</xs:complexType>

	<xs:complexType name="client-project-prices-writeable">
		<xs:sequence>
			<xs:element name="activity-price" type="client-project-activity-price-writeable" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="user-activity-price" type="client-project-user-activity-price-writeable" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="activity-group-internal-price" type="client-project-activity-group-internal-price-writeable" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="lead">
		<xs:sequence>
			<xs:element name="user" type="user-reference"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="fixed-price-planned-invoice">
		<xs:sequence>
			<xs:element name="id" type="fixed-price-planned-invoice-reference" minOccurs="0"/>
			<xs:element name="invoice-date" type="xs:date"/>
			<xs:element name="client-invoice" type="client-invoice-reference" minOccurs="0"/>
			<xs:element name="row" type="fixed-price-planned-invoice-row" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="fixed-price-planned-invoice-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="fixed-price-planned-invoice-row">
		<xs:sequence>
			<xs:element name="id" type="fixed-price-planned-invoice-row-reference" minOccurs="0"/>
			<xs:element name="product" type="product-reference"/>
			<xs:element name="quantity" type="xs:decimal"/>
			<xs:element name="unit" type="xs:string"/>
			<xs:element name="price" type="xs:long"/>
			<xs:element name="description" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="fixed-price-planned-invoice-row-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-project-write-off">
		<xs:sequence>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="accounting-amount" type="xs:long"/>
			<xs:element name="description" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:simpleType name="client-project-status-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Draft"/>
			<xs:enumeration value="Open"/>
			<xs:enumeration value="Closed"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="accounting-year-restriction-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="None"/>
			<xs:enumeration value="AllExceptA"/>
			<xs:enumeration value="AllExceptF"/>
			<xs:enumeration value="All"/>
			<xs:enumeration value="GrantAll"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="event-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="event-status">
		<xs:sequence>
			<xs:element name="type" type="event-status-type"/>
			<xs:element name="registration-user" type="user-reference"/>
			<xs:element name="registration-date" type="xs:date"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="event-restriction-status">
		<xs:sequence>
			<xs:element name="type" type="event-status-type"/>
			<xs:element name="registration-user" type="user-reference"/>
			<xs:element name="event-date" type="xs:date"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="user-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-article-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-payout-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-agreement-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="new-client">
		<xs:sequence>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="client-type" type="client-type"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-invoice-template-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-invoice-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="supplier-invoice-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-invoice-row-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue-reference">
		<xs:choice>
			<xs:element name="id" type="revenue-id"/>
			<xs:element name="external-id">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="id" type="xs:string"/>
						<xs:element name="revenue-ledger" type="revenue-ledger-reference"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:choice>
	</xs:complexType>

	<xs:complexType name="revenue-ledger-reference">
		<xs:sequence>
			<xs:element name="id" type="revenue-ledger-id"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue-row-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:simpleType name="revenue-id">
		<xs:restriction base="xs:long"/>
	</xs:simpleType>

	<xs:simpleType name="revenue-ledger-id">
		<xs:restriction base="xs:long"/>
	</xs:simpleType>

	<xs:complexType name="supplier-invoice-account-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="bank-account-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:long"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="bank-transaction-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:long"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="supplier-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="product-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="project-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="dimension-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="dimension-entry-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-broker-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-file-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-entry-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="expense-type-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="company-card-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="payroll-schedule-reference">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="address">
		<xs:sequence>
			<xs:element name="address1" type="xs:string"/>
			<xs:element name="address2" type="xs:string"/>
			<xs:element name="zip-code" type="xs:string"/>
			<xs:element name="state" type="xs:string"/>
			<xs:element name="country" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="field">
		<xs:sequence>
			<!-- Set when reading, ignored when creating/updating -->
			<xs:element name="name" type="xs:string" minOccurs="0"/>
			<!-- Alias uniquely identifies a field -->
			<xs:element name="alias" type="xs:string"/>
			<xs:element name="value" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="accrual">
		<xs:sequence>
			<xs:element name="month" type="xs:string"/>
			<xs:element name="sum" type="xs:long"/>
		</xs:sequence>
	</xs:complexType>

	<xs:simpleType name="invoice-day">
		<xs:restriction base="xs:string">
			<!-- Invoices will be created on the first day of each period -->
			<xs:enumeration value="INVOICE_AT_START"/>
			<!-- Invoices will be created so that the due day matches the first day of the period -->
			<xs:enumeration value="PAY_AT_START"/>
			<!-- Invoices will be created on the last day of each period -->
			<xs:enumeration value="INVOICE_AT_END"/>
			<!-- Invoices will be created on the start of the month before the month that encapsulates interval start -->
			<xs:enumeration value="INVOICE_AT_START_MONTH"/>
			<!-- Invoice 60 days prior to the period start -->
			<xs:enumeration value="INVOICE_60_DAYS_PRIOR_TO_PERIOD_START"/>
			<!-- Invoices will be created on the start of the month after the month that encapsulates interval end -->
			<xs:enumeration value="INVOICE_AT_END_MONTH"/>
			<!-- Invoice one day prior to the period start -->
			<xs:enumeration value="INVOICE_ONE_DAY_PRIOR_TO_PERIOD_START"/>
			<!-- Invoice one day prior to the period start -->
			<xs:enumeration value="INVOICE_FIVE_DAYS_PRIOR_TO_PERIOD_START"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="payroll-user-month-report-strategy">
		<xs:restriction base="xs:string">
			<xs:enumeration value="DontCreate"/>
			<xs:enumeration value="Create"/>
			<xs:enumeration value="CreateApproveSelf"/>
		</xs:restriction>
	</xs:simpleType>


	<xs:simpleType name="payroll-user-monthly-salary-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Next"/>
			<xs:enumeration value="Current"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="payroll-user-variable-salary-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Disabled"/>
			<xs:enumeration value="Provision"/>
			<xs:enumeration value="ProvisionWithVacation"/>
			<xs:enumeration value="Bonus"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="payroll-user-variable-salary-payout-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Current"/>
			<xs:enumeration value="Next"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="payroll-user-variable-salary-input-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Self"/>
			<xs:enumeration value="Other"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="payroll-user-variable-tax-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Normal"/>
			<xs:enumeration value="OneTime"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="payroll-user-employment-end-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Disabled"/>
			<xs:enumeration value="NextMonth"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="supplier-invoice-deposit-account-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="BankGiro"/>
			<xs:enumeration value="PlusGiro"/>
			<!-- Format: [\d\w]+-[\d\w]+ -->
			<xs:enumeration value="Iban"/>
			<!-- Format: \d+-\d+ -->
			<xs:enumeration value="BankAccount"/>
			<xs:enumeration value="Other"/>
			<!-- Format: [\d\w]+-[\d\w]+-[\d\w]+ -->
			<xs:enumeration value="InternationalBankAccountWithRouting"/>
			<!-- Format: [\d\w]+-[\d]+ -->
			<xs:enumeration value="InternationalBankAccountWithAccountNumber"/>
			<!-- Format: [\d\w]+-[\d\w]+-[\d]+ -->
			<xs:enumeration value="InternationalBankAccountViaIntermediary"/>
			<!-- Format: [\d\w]+-[\d\w]+-[\d\w]+-[\d]+-[\d]+-[\d]+ -->
			<xs:enumeration value="InternationalBankAccountInRussiaInRub"/>
			<!-- Format \d{11} -->
			<xs:enumeration value="NorwegianBankAccount"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="supplier-invoice-payee">
		<xs:sequence>
			<xs:element name="type" type="supplier-invoice-deposit-account-type"/>
			<xs:element name="nr" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="client-invoice-relation">
		<xs:sequence>
			<xs:element name="client-invoice-id" type="xs:int" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="supplier-invoice-relation">
		<xs:sequence>
			<xs:element name="supplier-invoice-id" type="xs:int" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:simpleType name="supplier-invoice-reminder-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="None"/>
			<xs:enumeration value="Reminder"/>
			<xs:enumeration value="DebtCollection"/>
			<xs:enumeration value="Enforcement"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="supplier-invoice-approval-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="APPROVAL"/>
			<xs:enumeration value="DENIAL"/>
			<xs:enumeration value="TIMEOUT"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="supplier-invoice-payment-status-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Pending"/>
			<xs:enumeration value="Processed"/>
			<xs:enumeration value="Completed"/>
			<xs:enumeration value="Failed"/>
			<xs:enumeration value="FailedAcknowledged"/>
			<xs:enumeration value="Cancelled"/>
			<xs:enumeration value="Lost"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="payroll-event-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Sick"/>
			<xs:enumeration value="Vacation"/>
			<xs:enumeration value="LeaveOfAbsence"/>
			<xs:enumeration value="LeaveOfAbsenceVacationEarned"/>
			<xs:enumeration value="WorkHour"/>
			<xs:enumeration value="ParentalLeave"/>
			<xs:enumeration value="Childcare"/>
			<xs:enumeration value="CloseRelativeCare"/>
			<xs:enumeration value="PaternityLeave"/>
			<xs:enumeration value="Furlough"/>
			<xs:enumeration value="OtherLeave"/>
			<xs:enumeration value="OtherLeaveVacationNotEarned"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="payroll-unit-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Generic"/>
			<xs:enumeration value="Mile"/>
			<xs:enumeration value="Hour"/>
			<xs:enumeration value="Day"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="payroll-schedule-interval-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Work"/>
			<xs:enumeration value="WorkReduced"/>
			<xs:enumeration value="WorkFree"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="access-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Auditor"/>
			<xs:enumeration value="Administrator"/>
			<xs:enumeration value="AdministratorWithPayroll"/>
			<xs:enumeration value="ClientAgreementOwn"/>
			<xs:enumeration value="ClientInvoice"/>
			<xs:enumeration value="ClientInvoiceRead"/>
			<xs:enumeration value="ClientInvoiceCreate"/>
			<xs:enumeration value="ClientInvoiceCertifyOwn"/>
			<xs:enumeration value="ClientInvoiceOwn"/>
			<xs:enumeration value="ClientInvoicePay"/>
			<xs:enumeration value="ClientProjectOwn"/>
			<xs:enumeration value="CustomerManagerSeb"/>
			<xs:enumeration value="DimensionOwn"/>
			<xs:enumeration value="Dimensions"/>
			<xs:enumeration value="Expenses"/>
			<xs:enumeration value="ExpensesOwn"/>
			<xs:enumeration value="ExpensesPay"/>
			<xs:enumeration value="Expert"/>
			<xs:enumeration value="ExternalAccountant"/>
			<xs:enumeration value="Manager"/>
			<xs:enumeration value="Payroll"/>
			<xs:enumeration value="PayrollRead"/>
			<xs:enumeration value="PayrollOwn"/>
			<xs:enumeration value="PayrollPay"/>
			<xs:enumeration value="Remuneration"/>
			<xs:enumeration value="RemunerationOwn"/>
			<xs:enumeration value="Responsible"/>
			<xs:enumeration value="ResponsibleRead"/>
			<xs:enumeration value="SupplierInvoice"/>
			<xs:enumeration value="SupplierInvoiceRead"/>
			<xs:enumeration value="SupplierInvoiceSecretRead"/>
			<xs:enumeration value="SupplierInvoiceCertifyOrg"/>
			<xs:enumeration value="SupplierInvoiceCreate"/>
			<xs:enumeration value="SupplierInvoicePay"/>
			<xs:enumeration value="Timereport"/>
			<xs:enumeration value="TimereportOwn"/>
			<xs:enumeration value="Subcontractor"/>
			<xs:enumeration value="PayrollSecret"/>
			<xs:enumeration value="PayrollSecretRead"/>
			<xs:enumeration value="FoundationGrantPay"/>
			<xs:enumeration value="FoundationGrant"/>
			<xs:enumeration value="AttachmentRequest"/>
			<xs:enumeration value="InternalTransferPay"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="vat-code-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="_3FEU"/>
			<xs:enumeration value="_3VEU"/>
			<xs:enumeration value="A"/>
			<xs:enumeration value="BVMB"/>
			<xs:enumeration value="E"/>
			<xs:enumeration value="FMOSS"/>
			<xs:enumeration value="FOBS"/>
			<xs:enumeration value="FOSS"/>
			<xs:enumeration value="FTEU"/>
			<xs:enumeration value="HFS"/>
			<xs:enumeration value="I"/>
			<xs:enumeration value="IT"/>
			<xs:enumeration value="ITEU"/>
			<xs:enumeration value="ITGLOB"/>
			<xs:enumeration value="IVGLOB"/>
			<xs:enumeration value="IV"/>
			<xs:enumeration value="IVEU"/>
			<xs:enumeration value="MF"/>
			<xs:enumeration value="MOSS"/>
			<xs:enumeration value="OBS"/>
			<xs:enumeration value="OSS"/>
			<xs:enumeration value="MP1"/>
			<xs:enumeration value="MP2"/>
			<xs:enumeration value="MP3"/>
			<xs:enumeration value="MP4"/>
			<xs:enumeration value="OTTU"/>
			<xs:enumeration value="R1"/>
			<xs:enumeration value="R2"/>
			<xs:enumeration value="U1"/>
			<xs:enumeration value="U2"/>
			<xs:enumeration value="U3"/>
			<xs:enumeration value="U4"/>
			<xs:enumeration value="UEU1"/>
			<xs:enumeration value="UEU2"/>
			<xs:enumeration value="UEU3"/>
			<xs:enumeration value="UEU4"/>
			<xs:enumeration value="UOS1"/>
			<xs:enumeration value="UOS2"/>
			<xs:enumeration value="UOS3"/>
			<xs:enumeration value="UOS4"/>
			<xs:enumeration value="UVFU1"/>
			<xs:enumeration value="UVFU2"/>
			<xs:enumeration value="UVFU3"/>
			<xs:enumeration value="UVFU4"/>
			<xs:enumeration value="UT"/>
			<xs:enumeration value="UTFU1"/>
			<xs:enumeration value="UTFU2"/>
			<xs:enumeration value="UTFU3"/>
			<xs:enumeration value="UTFU4"/>
			<xs:enumeration value="VTEU"/>
			<xs:enumeration value="OETEU"/>
			<xs:enumeration value="INGEN"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="expense-type-classification">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Basic"/>
			<xs:enumeration value="Representation"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="client-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Organisation"/>
			<xs:enumeration value="Person"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="event-status-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Open"/>
			<xs:enumeration value="Approved"/>
			<xs:enumeration value="Certified"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="purchase-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Goods"/>
			<xs:enumeration value="Services"/>
			<xs:enumeration value="DigitalServices"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="period">
		<xs:sequence>
			<xs:element name="start" type="xs:date"/>
			<xs:element name="end" type="xs:date"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="file">
		<xs:sequence>
			<xs:element name="filename" type="xs:string"/>
			<xs:element name="data" type="xs:hexBinary"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="paged-result">
		<xs:attribute name="offset" type="xs:int">
			<xs:annotation>
				<xs:documentation>
					The offset into the full result that this page represents, 0-indexed.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="limit" type="xs:int">
			<xs:annotation>
				<xs:documentation>
					The size that this page was limited to. May have been automatically adjusted compared to user input. This value also always
					represents the number of returned rows.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="size" type="xs:int">
			<xs:annotation>
				<xs:documentation>
					The total size of all rows. May be used to calculate number of calls required to fetch full result.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="report" abstract="true">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="company" type="company"/>
			<xs:element name="headers" type="report-header" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="sections" type="report-section" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="report-header">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="value" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="report-section" abstract="true">
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="report-section-simple-table">
		<xs:complexContent>
			<xs:extension base="report-section">
				<xs:sequence>
					<xs:element name="objects" type="report-section-simple-table-object" minOccurs="0"
								maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-simple-table-object" abstract="true">
		<xs:sequence>
			<xs:element name="items" type="report-section-model-item" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="report-section-model-header">
		<xs:complexContent>
			<xs:extension base="report-section-simple-table-object">
				<xs:sequence>
					<xs:element name="item" type="report-section-model-item"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-header-row">
		<xs:complexContent>
			<xs:extension base="report-section-simple-table-object"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-item-row">
		<xs:complexContent>
			<xs:extension base="report-section-simple-table-object"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-footer-row">
		<xs:complexContent>
			<xs:extension base="report-section-simple-table-object"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-item" abstract="true">
		<xs:sequence>
			<xs:element name="value" type="xs:anyType"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="report-section-model-bigdecimal-item">
		<xs:complexContent>
			<xs:extension base="report-section-model-item"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-bigamount-item">
		<xs:complexContent>
			<xs:extension base="report-section-model-item"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-currency-item">
		<xs:complexContent>
			<xs:extension base="report-section-model-item"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-date-item">
		<xs:complexContent>
			<xs:extension base="report-section-model-item"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-number-item">
		<xs:complexContent>
			<xs:extension base="report-section-model-item"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-percentage-item">
		<xs:complexContent>
			<xs:extension base="report-section-model-item"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-string-item">
		<xs:complexContent>
			<xs:extension base="report-section-model-item"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="report-section-model-yearmonth-item">
		<xs:complexContent>
			<xs:extension base="report-section-model-item"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="bank-information-validate-request">
		<xs:annotation>
			<xs:documentation>
				A bank validate request is used to validate account information according to our internal logic.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:annotation>
				<xs:documentation>
					Select what you want to validate.
				</xs:documentation>
			</xs:annotation>
			<xs:choice>
				<xs:element name="bic-iban">
					<xs:annotation>
						<xs:documentation>
							Validate a BIC and IBAN
						</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:sequence>
							<xs:element name="bic" type="xs:string"/>
							<xs:element name="iban" type="xs:string"/>
						</xs:sequence>
					</xs:complexType>
				</xs:element>
				<xs:element name="supplier-invoice-account" type="supplier-invoice-payee">
					<xs:annotation>
						<xs:documentation>
							Validate an account as it would be entered when creating a supplier invoice.
						</xs:documentation>
					</xs:annotation>
				</xs:element>
			</xs:choice>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="bank-information-validate-result">
		<xs:sequence>
			<xs:element name="success" type="xs:boolean">
				<xs:annotation>
					<xs:documentation>
						Did the validation pass? Please note that a passing validation does not guarantee that the specific
						account actually exists, it merely means that it passed all passive validation rules such as check digits etc.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="message" type="xs:string">
				<xs:annotation>
					<xs:documentation>
						Used when validation fails to supply a human-readable failure message. Always an empty string when validation passes.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="bank-transaction-consolidate-revenues">

		<xs:sequence>

			<xs:element name="require-full-consolidation" type="xs:boolean">
				<xs:annotation>
					<xs:documentation>
						If set to true, the following validations are performed:

						* Bank transaction's full amount must be accounted for
						* All references revenues must be fully consolidated

						Recommended to always set this to true for use cases when it is expected that a bank transaction only represents revenues that are paid in full.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="revenue" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Information about a revenue and a currency that should be consolidated. If a revenue was created with many different currencies, this
						element may be repeated.
					</xs:documentation>
				</xs:annotation>

				<xs:complexType>
					<xs:sequence>

						<xs:element name="revenue-reference" type="revenue-reference">
							<xs:annotation>
								<xs:documentation>
									Reference to the revenue to be consolidated.
								</xs:documentation>
							</xs:annotation>
						</xs:element>

						<xs:element name="bank-transaction-amount" type="xs:long">
							<xs:annotation>
								<xs:documentation>
									Amount from the bank transaction that this revenue represents, as given in the bank account's currency. For example, if the bank account
									under consideration is in USD, the amount should be given in the same currency.
								</xs:documentation>
							</xs:annotation>
						</xs:element>

						<xs:element name="revenue-amount" type="currency-amount">
							<xs:annotation>
								<xs:documentation>
									The amount to consolidate as given in a currency used by the revenue. If more than one currency needs to be consolidated for a single revenue, the
									revenue can be repeated. If the used currency is fully consolidated with respect to the revenue's remaining amount, currency win/loss will be
									automatically performed.
								</xs:documentation>
							</xs:annotation>
						</xs:element>

						<xs:element name="transaction-fees" type="revenue-transaction-fees"/>

					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="file" type="file" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						At least one file must be given, to use as basis for the accounting. Its format must be PDF.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue-fuzzy-consolidation">

		<xs:annotation>
			<xs:documentation>
				The general contract of this construction is that all the given bank transactions and revenues will be fully consolidated.
			</xs:documentation>
		</xs:annotation>

		<xs:sequence>

			<xs:element name="revenue-reference" type="revenue-reference" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Reference to a revenue to be consolidated.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="bank-transaction-reference" type="bank-transaction-reference" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Reference to a bank transaction to be consolidated.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="transaction-fees" type="revenue-transaction-fees"/>

			<xs:element name="previous-ledger" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If amounts from a previous ledger is known it can be specified here along with a desired account number to be credited.
					</xs:documentation>
				</xs:annotation>
				<xs:complexType>
					<xs:sequence>
						<xs:element name="account-nr" type="xs:int"/>
						<xs:element name="amount" type="currency-amount"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>

			<xs:element name="fx-amount" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						An optional currency win/loss amount that is used for sanity check the final result.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="file" type="file" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						At least one file must be given, to use as basis for the accounting. Its format must be PDF.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue-transaction-fees">
		<xs:annotation>
			<xs:documentation>
				Revenue transaction fees.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="currency-type" type="xs:string"/>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="vat" type="xs:long">
				<xs:annotation>
					<xs:documentation>
						If there is VAT associated with the fees given in the amount field, use this field to specify. This VAT represents an amount that is
						assumed to have already been subtracted from bank-transaction-amount.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="revenue-fuzzy-consolidation-result">

		<xs:sequence>

			<xs:element name="bank-transaction-count" type="xs:int">
				<xs:annotation>
					<xs:documentation>
						Number of consolidated bank transactions.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="revenue-count" type="xs:int">
				<xs:annotation>
					<xs:documentation>
						Number of consolidated revenues.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="bank-transaction-accounting-amount" type="xs:long">
				<xs:annotation>
					<xs:documentation>
						Total accounting amount of consolidated bank transactions.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="revenue-accounting-amount" type="xs:long">
				<xs:annotation>
					<xs:documentation>
						Total accounting amount of consolidated revenues.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="create-bank-transaction">
		<xs:sequence>
			<xs:element name="bankAccountId" type="xs:long"/>
			<xs:element name="date" type="xs:date"/>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="reference" type="xs:string"/>
			<xs:element name="description" type="xs:string"/>
			<xs:element name="files">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="bank-transaction-distributions">
		<xs:sequence>
			<xs:element name="bank-transaction-distribution" type="bank-transaction-distribution" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="bank-transaction-distribution">
		<xs:sequence>
			<xs:element name="id" type="xs:long"/>
			<xs:element name="client-invoice" type="client-invoice-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reference to the client invoice.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="revenue" type="revenue-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reference to the revenue.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="supplier-invoice" type="supplier-invoice-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reference to the supplier invoice.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="comment" type="xs:string"/>
			<xs:element name="native-amount" type="currency-amount">
				<xs:annotation>
					<xs:documentation>
						The native amount given in a currency used by the distribution.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="accounting-amount" type="xs:long"/>
			<xs:element name="registration-date" type="xs:date"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="create-foundation-grant">
		<xs:sequence>
			<xs:element name="recipient" type="xs:string"/>
			<xs:element name="currency-amount" type="currency-amount"/>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="case-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="dimensions-distribution" type="dimensions-distribution"/>
			<xs:element name="files">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="decision-date" type="xs:date"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="foundation-grant-update">
		<xs:sequence>
			<xs:element name="recipient" type="xs:string" minOccurs="0"/>
			<xs:element name="grant-amount" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="amount" type="xs:long"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="dimensions-distribution" type="dimensions-distribution" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="foundation-grant-return">
		<xs:sequence>
			<xs:element name="decision-date" type="xs:date"/>
			<xs:element name="files">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="foundation-grant-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="recipient" type="xs:string"/>
			<xs:element name="currency-amount" type="currency-amount"/>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="case-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="decision-date" type="xs:date"/>
			<xs:element name="returned" type="xs:boolean"/>
			<xs:element name="deleted" type="xs:boolean"/>
			<xs:element name="dimensions" type="dimensions-distribution" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="create-foundation-grant-payment">
		<xs:sequence>
			<xs:element name="grant-id" type="xs:int"/>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="case-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="recipient">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="name" type="xs:string"/>
						<xs:element name="identifier" type="xs:string"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="deposit-account" type="supplier-invoice-payee" minOccurs="0"/>
			<xs:element name="payment-date" type="xs:date" minOccurs="0"/>
			<xs:element name="payment-amount">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="amount" type="xs:long"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="files" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="ocr" minOccurs="0" type="xs:string"/>
			<xs:element name="reference-nr" minOccurs="0" type="xs:string"/>
			<xs:element name="payment-type" type="foundation-grant-payment-type" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="create-foundation-grant-repayment">
		<xs:sequence>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="grant-id" type="xs:int"/>
			<xs:element name="decision-date" type="xs:date"/>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="file" type="file"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="update-foundation-grant-payment">
		<xs:sequence>
			<xs:element name="recipient" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="name" type="xs:string" minOccurs="0"/>
						<xs:element name="identifier" type="xs:string" minOccurs="0"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="deposit-account" type="supplier-invoice-payee" minOccurs="0"/>
			<xs:element name="payment-date" type="xs:date" minOccurs="0"/>
			<xs:element name="payment-amount" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="amount" type="xs:long" minOccurs="0"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="ocr" minOccurs="0" type="xs:string"/>
			<xs:element name="reference-nr" minOccurs="0" type="xs:string"/>
			<xs:element name="payment-type" type="foundation-grant-payment-type" minOccurs="0"/>
			<xs:element name="files" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="file" maxOccurs="unbounded" type="file"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="foundation-grant-payment-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="grant-id" type="xs:int"/>
			<xs:element name="foreign-id" type="xs:string"/>
			<xs:element name="case-nr" type="xs:string" minOccurs="0"/>
			<xs:element name="status" type="xs:string"/>
			<xs:element name="recipient">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="name" type="xs:string"/>
						<xs:element name="identifier" type="xs:string"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="deposit-account" type="supplier-invoice-payee"/>
			<xs:element name="payment-date" type="xs:date"/>
			<xs:element name="payment-amount">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="amount" type="xs:long"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="remaining-amount" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="amount" type="xs:long"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
			<xs:element name="ocr" minOccurs="0" type="xs:string"/>
			<xs:element name="reference-nr" minOccurs="0" type="xs:string"/>
			<xs:element name="payment-type" type="foundation-grant-payment-type" minOccurs="0"/>
			<xs:element name="supplierInvoices" minOccurs="0">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="supplierInvoice" maxOccurs="unbounded" type="foundation-grant-payment-invoice"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="foundation-grant-repayment-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="grant-id" type="xs:int"/>
			<xs:element name="decision-date" type="xs:date"/>
			<xs:element name="amount">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="amount" type="xs:long"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:simpleType name="foundation-grant-payment-type">
		<xs:restriction base="xs:string">
			<xs:enumeration value="SupplierInvoice"/>
			<xs:enumeration value="Payroll"/>
			<xs:enumeration value="BankTransfer"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="foundation-grant-payment-invoice">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="amount" type="xs:long"/>
			<xs:element name="certified" type="xs:boolean"/>
			<xs:element name="paid" type="xs:boolean"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="sub-foundation-readable">
		<xs:sequence>
			<xs:element name="id" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="orgno" type="xs:string"/>
			<xs:element name="dimension-entry" type="dimension-entry-reference"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="eurocard-files-request">
		<xs:sequence>
			<xs:element name="from-date" minOccurs="0" type="xs:date"/>
			<xs:element name="to-date" minOccurs="0" type="xs:date"/>
			<xs:element name="orgno" minOccurs="0" type="xs:string"/>
			<xs:element name="filename" minOccurs="0" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="budgets">
		<xs:sequence>
			<xs:element name="budget" type="budget" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="budget">
		<xs:sequence>
			<xs:element name="id" type="xs:int"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="active" type="xs:boolean"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="budget-accounts">
		<xs:complexContent>
			<xs:extension base="paged-result">
				<xs:sequence>
					<xs:element name="budget-account" type="budget-account" minOccurs="0" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="budget-account">
		<xs:sequence>

			<xs:element name="account-nr" type="xs:int"/>

			<xs:element name="year" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Not set when the amounts are accumulated over the requested period.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="month" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Zero based, so January is 0 and December is 11.
						Not set when the amounts are accumulated over the requested period.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="amount" type="xs:long">
				<xs:annotation>
					<xs:documentation>
						In hundredths of the accounting currency, so 123,45 is 12345.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

			<xs:element name="dimension-entry" type="dimension-entry-reference" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Only set when the amounts are broken down per dimension entry.
					</xs:documentation>
				</xs:annotation>
			</xs:element>

		</xs:sequence>
	</xs:complexType>

</xs:schema>