package pt.ist.expenditureTrackingSystem.domain;


enum pt.ist.expenditureTrackingSystem.domain.acquisitions.AcquisitionItemClassification as AcquisitionItemClassification;
enum pt.ist.expenditureTrackingSystem.domain.acquisitions.AcquisitionProcessStateType as AcquisitionProcessStateType;
enum pt.ist.expenditureTrackingSystem.domain.acquisitions.RefundProcessStateType as RefundProcessStateType;
enum pt.ist.expenditureTrackingSystem.domain.acquisitions.StandardAcquisitionProcessStateType as StandardAcquisitionProcessStateType;
enum pt.ist.expenditureTrackingSystem.domain.acquisitions.afterthefact.AfterTheFactAcquisitionType as AfterTheFactAcquisitionType;
enum pt.ist.expenditureTrackingSystem.domain.announcements.AnnouncementProcessStateType as AnnouncementProcessStateType;
enum pt.ist.expenditureTrackingSystem.domain.authorizations.AuthorizationType as AuthorizationType;
enum pt.ist.expenditureTrackingSystem.domain.RoleType as RoleType;
enum pt.ist.expenditureTrackingSystem.domain.authorizations.AuthorizationOperation as AuthorizationOperation;
enum pt.ist.expenditureTrackingSystem.domain.acquisitions.simplified.SimplifiedProcedureProcess.ProcessClassification as ProcessClassification;
enum pt.ist.expenditureTrackingSystem.domain.acquisitions.search.SearchPaymentProcess.SearchProcessValues as SearchProcessValues;
enum pt.ist.expenditureTrackingSystem.domain.acquisitions.search.SearchProcessValues as SearchProcessValues;




valueType pt.utl.ist.fenix.tools.util.Strings as Strings {
    externalizeWith {
        String exportAsString();
    }

    internalizeWith importFromString();
}

valueType pt.utl.ist.fenix.tools.util.ByteArray as ByteArray {
    externalizeWith {
        bytearray getBytes();
    }
}

valueType pt.ist.bennu.core.domain.util.Address as Address {
    externalizeWith {
        String exportAsString();
    }

    internalizeWith importFromString();
}

valueType pt.ist.bennu.core.domain.util.Money as Money {
    externalizeWith {
        String exportAsString();
    }

    internalizeWith importFromString();
}

valueType java.math.BigDecimal as BigDecimal {
    externalizeWith {
        String toString();
    }
}

valueType pt.ist.expenditureTrackingSystem.domain.acquisitions.search.SearchProcessValuesArray as SearchProcessValuesArray {
    externalizeWith {
        String exportAsString();
    }

    internalizeWith importFromString();
}


class ExpenditureTrackingSystem {
	Integer acquisitionRequestDocumentCounter;
	SearchProcessValuesArray searchProcessValuesArray;
	String acquisitionCreationWizardJsp;
	String institutionalProcessNumberPrefix;
	String institutionalRequestDocumentPrefix;
	Boolean invoiceAllowedToStartAcquisitionProcess;
	Boolean requireFundAllocationPriorToAcquisitionRequest;
	Boolean registerDiaryNumbersAndTransactionNumbers;
	Boolean requireCommitmentNumber;
	Money maxValueStartedWithInvoive;
	Money valueRequireingTopLevelAuthorization;
	String documentationUrl;
	String documentationLabel;
	Boolean checkSupplierLimitsByCPV;
	String institutionManagementEmail;
}


class acquisitions.Acquisition implements .pt.ist.bennu.core.domain.VirtualHostAware {
}

	class acquisitions.RequestWithPayment extends acquisitions.Acquisition {
	
	}
	
	class acquisitions.refund.RefundRequest extends acquisitions.RequestWithPayment {
		String paymentReference;
	} 
	
	class acquisitions.afterthefact.AcquisitionAfterTheFact extends acquisitions.Acquisition {
		AfterTheFactAcquisitionType afterTheFactAcquisitionType;
		Money value;
		BigDecimal vatValue;
		String description;
		Boolean deletedState;
	}

	class acquisitions.AcquisitionRequest extends acquisitions.RequestWithPayment {
		String paymentReference;
		String contractSimpleDescription;
	}

class acquisitions.CPVReference {
	String code;
	String description;
}

class announcements.Announcement implements .pt.ist.bennu.core.domain.VirtualHostAware {
	String description;
	Money totalPrice;
	DateTime creationDate;
	Boolean active;
}

	class announcements.CCPAnnouncement extends announcements.Announcement {
		Integer executionDays;
		String executionAddress;
		String choiceCriteria;
	}

	class announcements.RCISTAnnouncement extends announcements.Announcement {
	}

class acquisitions.PaymentProcessYear implements .pt.ist.bennu.core.domain.VirtualHostAware {
	Integer year;
	Integer counter;
}

class acquisitions.RequestItem implements .pt.ist.bennu.core.domain.VirtualHostAware {
	String description;
	AcquisitionItemClassification classification;
}
 
	class acquisitions.refund.RefundItem extends acquisitions.RequestItem {
		Money valueEstimation;
		Boolean itemNotExecuted;
	}

	class acquisitions.AcquisitionRequestItem extends acquisitions.RequestItem {
		Integer quantity;
		Money unitValue;
		BigDecimal vatValue;
		Money additionalCostValue;
		String proposalReference;
		String recipient;
		String recipientPhone;
		String recipientEmail;
		Address address;
	
		Integer realQuantity;
		BigDecimal realVatValue;
		Money realUnitValue;
		Money realAdditionalCostValue;
	}

class acquisitions.UnitItem implements .pt.ist.bennu.core.domain.VirtualHostAware {
	Boolean submitedForFundsAllocation;
	Boolean itemAuthorized;
	Boolean invoiceConfirmed;
	Money shareValue;
	Money realShareValue;
}

class acquisitions.Financer implements .pt.ist.bennu.core.domain.VirtualHostAware {
	String fundAllocationId;
	Strings effectiveFundAllocationId;
	Strings paymentDiaryNumber;
	Strings transactionNumber;
	String commitmentNumber;
}

	class acquisitions.ProjectFinancer extends acquisitions.Financer {
		String projectFundAllocationId;
		Strings effectiveProjectFundAllocationId;
	}

class authorizations.Authorization implements .pt.ist.bennu.core.domain.VirtualHostAware {
	AuthorizationType authorizationType;
	Boolean canDelegate;
	LocalDate startDate;
	LocalDate endDate;
	Money maxAmount;
	
}	

	class authorizations.DelegatedAuthorization extends authorizations.Authorization {
	}

class authorizations.AuthorizationLog implements .pt.ist.bennu.core.domain.VirtualHostAware {
	DateTime whenOperationWasRan;
	AuthorizationOperation authorizationOperation;
	AuthorizationType authorizationType;
	Boolean canDelegate;
	LocalDate startDate;
	LocalDate endDate;
	Money maxAmount;
	String justification;
}	

class acquisitions.afterthefact.ImportFile extends .pt.ist.fenixframework.plugins.fileSupport.domain.GenericFile implements .pt.ist.bennu.core.domain.VirtualHostAware {
	Boolean active;
}
	
class acquisitions.AcquisitionProposalDocument extends .module.workflow.domain.ProcessFile implements .pt.ist.bennu.core.domain.VirtualHostAware {
	String proposalId;
}

class acquisitions.CreditNoteDocument extends .module.workflow.domain.ProcessFile implements .pt.ist.bennu.core.domain.VirtualHostAware {
}
	
class acquisitions.PurchaseOrderDocument extends .module.workflow.domain.ProcessFile implements .pt.ist.bennu.core.domain.VirtualHostAware {
	String requestId;
}
	
class acquisitions.Invoice extends .module.workflow.domain.ProcessFile implements .pt.ist.bennu.core.domain.VirtualHostAware {
	String invoiceNumber;
	LocalDate invoiceDate;
}
	
	class acquisitions.afterthefact.AfterTheFactInvoice extends acquisitions.Invoice {
	}
	
	class acquisitions.PaymentProcessInvoice extends acquisitions.Invoice {
	}
	
		class acquisitions.AcquisitionInvoice extends acquisitions.PaymentProcessInvoice {
			String confirmationReport;
		}
	
		class acquisitions.refund.RefundableInvoiceFile extends acquisitions.PaymentProcessInvoice {
			Money value;
			BigDecimal vatValue;
			Money refundableValue;
		}
	
class Options implements .pt.ist.bennu.core.domain.VirtualHostAware {
	Boolean displayAuthorizationPending;
	Boolean recurseAuthorizationPendingUnits;
	Boolean receiveNotificationsByEmail;
}

class organization.AccountingUnit implements .pt.ist.bennu.core.domain.VirtualHostAware {
	String name;
}

class organization.Person {
	String name;
	String username;
	String password;
	String email;
	DateTime logoutDateTime;
}

class SavedSearch implements .pt.ist.bennu.core.domain.VirtualHostAware {
	String searchName;
	SearchProcessValues searchProcessValues;
	String processId;
	Boolean pendingOperations;
	Boolean showOnlyResponsabilities;
	String requestDocumentId;
	AcquisitionProcessStateType acquisitionProcessStateType;
    RefundProcessStateType refundProcessStateType;
 	String proposalId;
 	Boolean showOnlyAcquisitionsExcludedFromSupplierLimit;
    Boolean showOnlyAcquisitionsWithAdditionalCosts;
    String refundeeName;
	Boolean showOnlyWithUnreadComments;
	Boolean showPriorityOnly;
}

	class MyOwnProcessesSearch extends SavedSearch {
	}

	class PendingProcessesSearch extends SavedSearch {
	}

class organization.DeliveryInfo {
	String recipient;
	Address address;
	String phone;
	String email;
}

class organization.Supplier extends .module.finance.domain.Supplier {
}

class organization.Unit implements .pt.ist.bennu.core.domain.VirtualHostAware {
	Boolean defaultRegeimIsCCP;
}

	class organization.CostCenter extends organization.Unit {
	}

	class organization.Project extends organization.Unit {
	}

	class organization.SubProject extends organization.Unit {
	}

class announcements.OperationLog extends .module.workflow.domain.ActivityLog implements .pt.ist.bennu.core.domain.VirtualHostAware {
	AnnouncementProcessStateType state;
}

class processes.GenericProcess extends .module.workflow.domain.WorkflowProcess implements .pt.ist.bennu.core.domain.VirtualHostAware {
}

	class acquisitions.PaymentProcess extends processes.GenericProcess {
		Integer acquisitionProcessNumber;	
		Boolean skipSupplierFundAllocation;
	}

	class acquisitions.AcquisitionProcess extends acquisitions.PaymentProcess {
		LocalDate fundAllocationExpirationDate;
	}

		class acquisitions.afterthefact.AfterTheFactAcquisitionProcess extends acquisitions.AcquisitionProcess {
		}

			class acquisitions.RegularAcquisitionProcess extends acquisitions.AcquisitionProcess {
			}
			
			class acquisitions.simplified.SimplifiedProcedureProcess extends acquisitions.RegularAcquisitionProcess {
				ProcessClassification processClassification;
			}

			class acquisitions.standard.StandardProcedureProcess extends acquisitions.RegularAcquisitionProcess {
			}

	class announcements.AnnouncementProcess extends processes.GenericProcess {
	}

	class acquisitions.refund.RefundProcess extends acquisitions.PaymentProcess {
		Boolean underCCPRegime;
	}
	
class acquisitions.refund.Refundee implements .pt.ist.bennu.core.domain.VirtualHostAware {
	String name;
	String fiscalCode;
} 
	
class ProcessState implements .pt.ist.bennu.core.domain.VirtualHostAware {
	DateTime whenDateTime;
	String justification;
}
	
	class acquisitions.AcquisitionProcessState extends ProcessState {
		AcquisitionProcessStateType acquisitionProcessStateType;
	}

	class announcement.AnnouncementProcessState extends ProcessState {
		AnnouncementProcessStateType announcementProcessStateType;
	}

	class acquisitions.RefundProcessState extends ProcessState {
		RefundProcessStateType refundProcessStateType;
	}


class Role implements .pt.ist.bennu.core.domain.VirtualHostAware {
	RoleType roleType;
}

class DashBoard implements .pt.ist.bennu.core.domain.VirtualHostAware {
	Strings column1;
	Strings column2;
	Strings column3;
}

class acquisitions.ProjectAcquisitionFundAllocationRequest extends .module.externalAccountingIntegration.domain.FundAllocationRequest {
}

class acquisitions.AcquisitionFundAllocationDiaryAndTransactionReportRequest extends .module.externalAccountingIntegration.domain.ExternalRequest {
	String processId;
	String payingUnitNumber;
	String payingAccountingUnit;
	String diaryNumber;
	String transactionNumber;
}

class organization.UnitActiveResponsibleGroup extends .pt.ist.bennu.core.domain.groups.PersistentGroup { }

	class organization.ProjectActiveResponsibleGroup extends organization.UnitActiveResponsibleGroup { }

	class organization.CostCenterActiveResponsiblesGroup extends organization.UnitActiveResponsibleGroup { }


relation ExpenditureTrackingSystemDashBoard {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	DashBoard playsRole dashBoards {
		multiplicity *;
	}
}

relation PersonDashBoard {
	organization.Person playsRole person;
	DashBoard playsRole dashBoard;
}

relation ExpenditureTrackingSystemGenericProcess {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	processes.GenericProcess playsRole processes {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemAcquisition {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	acquisitions.Acquisition playsRole acquisitions {
		multiplicity *;
	}
}

relation AcquisitionProcessAcquisitionRequest {
	acquisitions.AcquisitionProcess playsRole acquisitionProcess;
	acquisitions.AcquisitionRequest playsRole acquisitionRequest;
}


relation AnnouncementProcessAnnouncement {
	announcements.AnnouncementProcess playsRole announcementProcess;
	announcements.CCPAnnouncement playsRole announcement;
}

relation ExpenditureTrackingSystemAcquisitionRequestItem {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	acquisitions.RequestItem playsRole requestItems {
		multiplicity *;
	}
}

relation AcquisitionRequestAcquisitionRequestItem {
	acquisitions.RequestWithPayment playsRole request;
	acquisitions.RequestItem playsRole requestItems {
		multiplicity *;
	}
}

relation PaymentProcessInvoiceRequestItem {
	acquisitions.PaymentProcessInvoice playsRole invoicesFiles {
		multiplicity *;
	}
	acquisitions.RequestItem playsRole requestItems {
		multiplicity *;
	}
}

relation PaymentProcessInvoiceUnitItem {
	acquisitions.PaymentProcessInvoice playsRole confirmedInvoices {
		multiplicity *;
	}
	acquisitions.UnitItem playsRole unitItems {
		multiplicity *;
	}
}

relation FundsAllocatedPermanentlyForFinancer {
	acquisitions.PaymentProcessInvoice playsRole allocatedInvoices {
		multiplicity *;
	}
	acquisitions.Financer playsRole financers {
		multiplicity *;
	}
}

relation FundsAllocatedPermanentlyForProjectFinancer {
	acquisitions.PaymentProcessInvoice playsRole allocatedInvoicesInProject {
		multiplicity *;
	}
	acquisitions.ProjectFinancer playsRole projectFinancers {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemPerson {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	organization.Person playsRole people {
		multiplicity *;
	}
}

relation MyOrgExpenditureTrackingSystemPerson {
	.pt.ist.bennu.core.domain.MyOrg playsRole myOrg;
	organization.Person playsRole peopleFromExpenditureTackingSystem {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemUnit {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	organization.Unit playsRole units {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemTopLevelUnits {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromTopLevelUnit;
	organization.Unit playsRole topLevelUnits {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemAuthorization {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	authorizations.Authorization playsRole authorizations {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemAuthorizationLog {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	authorizations.AuthorizationLog playsRole authorizationLogs {
		multiplicity *;
	}
}

relation UnitAuthorization {
	organization.Unit playsRole unit;
	authorizations.Authorization playsRole authorizations {
		multiplicity *;
	}
}

relation PersonAuthorization {
	organization.Person playsRole person;
	authorizations.Authorization playsRole authorizations {
		multiplicity *;
	}
}

relation PersonAuthorizationLog {
	organization.Person playsRole person;
	authorizations.AuthorizationLog playsRole authorizationLogs {
		multiplicity *;
	}
}

relation WhoAuthorizationLog {
	organization.Person playsRole who;
	authorizations.AuthorizationLog playsRole authorizationLogsForWho {
		multiplicity *;
	}
}

relation UnitAuthorizationLog {
	organization.Unit playsRole unit;
	authorizations.AuthorizationLog playsRole authorizationLogs {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemOptions {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	Options playsRole options {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemSuppliers {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	organization.Supplier playsRole suppliers {
		multiplicity *;
	}
}

relation MyOrgSuppliers {
	.pt.ist.bennu.core.domain.MyOrg playsRole myOrg;
	organization.Supplier playsRole suppliers {
		multiplicity *;
	}
}

relation PersonOptions {
	organization.Person playsRole person;
	Options playsRole options;
}

relation ExpenditureTrackingSystemRole {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	Role playsRole roles {
		multiplicity *;
	}
}

relation PersonRole {
	organization.Person playsRole person {
		multiplicity *;
	}
	Role playsRole roles {
		multiplicity *;
	}
} 

relation AcquisitionRequestSupplier {
	acquisitions.AcquisitionRequest playsRole possibleAcquisitionRequests {
		multiplicity *;
	}
	organization.Supplier playsRole suppliers {
		multiplicity *;
	}
}

relation AcquisitionRequestSelectedSupplier {
	acquisitions.AcquisitionRequest playsRole acquisitionRequests {
		multiplicity *;
	}
	organization.Supplier playsRole selectedSupplier;
}

relation AcquisitionRequestRequester {
	organization.Person playsRole requester;
	acquisitions.RequestWithPayment  playsRole requestsWithyPayment {
		multiplicity *;
	}
}

relation AcquisitionRequestRefundee {
	organization.Person playsRole refundee;
	acquisitions.AcquisitionRequest playsRole refundedAcquisitionRequests {
		multiplicity *;
	}
}

relation ProcessStatePerson {
	organization.Person playsRole who;
	ProcessState playsRole processStates {
		multiplicity *;
	}
}

relation GenericProcessProcessState {
	processes.GenericProcess playsRole process;
	ProcessState playsRole processStates {
		multiplicity *;
	}
}

relation GenericProcessCurrentProcessState {
	processes.GenericProcess playsRole;
	ProcessState playsRole currentProcessState;
}

relation ExpenditureTrackingSystemProcessState {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	ProcessState playsRole processStates {
		multiplicity *;
	}
}

relation AcquisitionRequestRequestingUnit {
	acquisitions.RequestWithPayment playsRole requests {
		multiplicity *;
	}
	organization.Unit playsRole requestingUnit;
}

relation RequestFinancer {
	acquisitions.RequestWithPayment playsRole fundedRequest;
	acquisitions.Financer playsRole financers {
		multiplicity *;
	}
}

relation UnitItemFinancer {
	acquisitions.Financer playsRole financer;
	acquisitions.UnitItem playsRole unitItems {
		multiplicity *;
	}
}

relation UnitFinancer {
	acquisitions.Financer playsRole financedItems{
		multiplicity *;
	}
	organization.Unit playsRole unit;
}

relation AccountingUnitFinancer {
	acquisitions.Financer playsRole financers{
		multiplicity *;
	}
	organization.AccountingUnit playsRole accountingUnit;
}

relation ItemUnitItem {
	acquisitions.RequestItem playsRole item;
	acquisitions.UnitItem playsRole unitItems {
		multiplicity *;
	}
}

relation PersonDeliveryInfo {
	organization.Person playsRole person;
	organization.DeliveryInfo playsRole deliveryInfos {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemFinancer {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	acquisitions.Financer playsRole financers {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemDeliveryInfo {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	organization.DeliveryInfo playsRole deliveryInfos {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemCPVReference {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	acquisitions.CPVReference playsRole cPVReferences {
		multiplicity *;
	}
}

relation MyOrgCPVReference {
	.pt.ist.bennu.core.domain.MyOrg playsRole myOrg;
	acquisitions.CPVReference playsRole cPVReferences {
		multiplicity *;
	}
}

relation ExpenditureTrackingSystemPriorityCPVReference {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemForPriorities;
	acquisitions.CPVReference playsRole priorityCPVReferences {
		multiplicity *;
	}
}


relation AcquisitionRequestItemCPVReference {
	acquisitions.CPVReference playsRole cPVReference;
	acquisitions.RequestItem playsRole acquisitionItems {
		multiplicity *;
	}
}

relation DelegatedAuthorizationAuthorization {
	authorizations.DelegatedAuthorization playsRole delegatedAuthorizations {
		multiplicity *;
	}	
	authorizations.Authorization playsRole authorization; 
}
relation AfterTheFactAcquisitionProcessAcquisitionAfterTheFact {
	acquisitions.afterthefact.AfterTheFactAcquisitionProcess playsRole afterTheFactAcquisitionProcess;
	acquisitions.afterthefact.AcquisitionAfterTheFact playsRole acquisitionAfterTheFact;
}

relation AcquisitionAfterTheFactSupplier {
	acquisitions.afterthefact.AcquisitionAfterTheFact playsRole acquisitionsAfterTheFact {
		multiplicity *;
	}
	organization.Supplier playsRole supplier;
}

relation ExpenditureTrackingSystemAnnouncement {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	announcements.Announcement playsRole announcements {
		multiplicity *;
	}
}

relation AnnoucementBuyingUnit {
	organization.Unit playsRole buyingUnit;
	announcements.CCPAnnouncement playsRole buyAnnouncements {
		multiplicity *;
	}
}

relation AnnoucementRequestingUnit {
	organization.Unit playsRole requestingUnit;
	announcements.CCPAnnouncement playsRole requestAnnouncements {
		multiplicity *;
	}
}

relation AnnouncementSupplier {
	announcements.CCPAnnouncement playsRole announcements {
		multiplicity *;
	}
	organization.Supplier playsRole supplier;
}

relation AnnouncementPublisher {
	organization.Person playsRole publisher;
	announcements.CCPAnnouncement playsRole announcements {
		multiplicity *;
	}
}

relation AnnouncementAcquisition {
	announcements.Announcement playsRole announcement;
	acquisitions.Acquisition playsRole acquisition;
}

relation ExpenditureTrackingSystemPaymentProcessYear {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	acquisitions.PaymentProcessYear playsRole paymentProcessYears {
		multiplicity *;
	}
}

relation PaymentProcessPaymentProcessYear {
	acquisitions.PaymentProcess playsRole paymentProcess {
		multiplicity *;
	} 
	acquisitions.PaymentProcessYear playsRole paymentProcessYear;
}

relation ExpenditureTrackingSystemAccountingUnit {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	organization.AccountingUnit playsRole accountingUnits {
		multiplicity *;
	}
}

relation PersonAccountingUnit {
	organization.Person playsRole people {
		multiplicity *;
	}
	organization.AccountingUnit playsRole accountingUnits {
		multiplicity *;
	}
}

relation ResponsibleAccountingUnit {
	organization.Person playsRole responsiblePeople {
		multiplicity *;
	}
	organization.AccountingUnit playsRole responsibleAccountingUnits {
		multiplicity *;
	}
}

relation PersonProjectAccountingUnit {
	organization.Person playsRole projectAccountants {
		multiplicity *;
	}
	organization.AccountingUnit playsRole projectAccountingUnits {
		multiplicity *;
	}
}

relation ResponsibleProjectAccountingUnit {
	organization.Person playsRole responsibleProjectAccountants {
		multiplicity *;
	}
	organization.AccountingUnit playsRole responsibleProjectAccountingUnits {
		multiplicity *;
	}
}

relation PersonTreasuryAccountingUnit {
	organization.Person playsRole treasuryMembers {
		multiplicity *;
	}
	organization.AccountingUnit playsRole treasuryAccountingUnits {
		multiplicity *;
	}
}

relation UnitAccountingUnit {
	organization.Unit playsRole units {
		multiplicity *;
	}
	organization.AccountingUnit playsRole accountingUnit;
}

relation AfterTheFactImportFile {
	acquisitions.afterthefact.AfterTheFactAcquisitionProcess playsRole afterTheFactAcquisitionProcesses {
		multiplicity *;
	}
	acquisitions.afterthefact.ImportFile playsRole importFile;
}

relation RefundableInvoiceFileSupplier {
	acquisitions.refund.RefundableInvoiceFile playsRole refundInvoices {
		multiplicity *;
	}
	organization.Supplier playsRole supplier;
}

relation RefundRequestRefundProcess {
	acquisitions.refund.RefundRequest playsRole request;
	acquisitions.refund.RefundProcess  playsRole process;
}

relation RefundeeExpenditureTrackingSystem {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	acquisitions.refund.Refundee playsRole refundees {
		multiplicity *;
	}
}

relation RefundRequestRefundee {
	acquisitions.refund.RefundRequest playsRole refundRequests {
		multiplicity *;
	}
	acquisitions.refund.Refundee playsRole refundee;
}

relation PersonRefundee {
	organization.Person playsRole person;
	acquisitions.refund.Refundee playsRole refundee;
}

relation PersonSavedSearch {
	organization.Person playsRole person;
	SavedSearch playsRole saveSearches {
		multiplicity *;
	}
}

relation RequestorSavedSearch {
	organization.Person playsRole requestor;
	SavedSearch playsRole requestorSearches {
		multiplicity *;
	}
}

relation TakerSavedSearch {
	organization.Person playsRole takenBy;
	SavedSearch playsRole takenSearches {
		multiplicity *;
	}
}

relation CPVReferenceSavedSearch {
	acquisitions.CPVReference playsRole cpvReference;
	SavedSearch playsRole savedSearch {
		multiplicity *;
	}
}

relation AccountManagerSavedSearch {
	organization.Person playsRole accountManager;
	SavedSearch playsRole accountManagerSearches {
		multiplicity *;
	}
}

relation AccountingUnitSavedSearch {
	organization.AccountingUnit playsRole accountingUnit;
	SavedSearch playsRole accountingUnitsSearches {
		multiplicity *;
	}
}

relation requestingUnitSavedSearch {
	organization.Unit playsRole unit;
	SavedSearch playsRole unitSearches {
		multiplicity *;
	}
}

relation payingUnitSavedSearch {
	organization.Unit playsRole payingUnit;
	SavedSearch playsRole payingUnitSearches {
		multiplicity *;
	}
}

relation PaymentProcessYearSavedSearch {
	acquisitions.PaymentProcessYear playsRole year;
	SavedSearch playsRole yearSearches {
		multiplicity *;
	}
}

relation SavedSearchExpenditureTrackingSystem {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem;
	SavedSearch playsRole savedSearches {
		multiplicity *;
	}
}

relation SupplierSavedSearch {
	organization.Supplier playsRole supplier;
	SavedSearch playsRole supplierSearches {
		multiplicity *;
	}
}

relation PersonDefaultSavedSearch {
	SavedSearch playsRole defaultSearch;
	organization.Person playsRole people {
		multiplicity *;
	}
}

relation SystemSearchesExpenditureTrackingSystem {
	SavedSearch playsRole systemSearches {
		multiplicity *;
	}
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemForSystemSearch;
}

relation UnitObservers {
	organization.Unit playsRole observableUnits {
		multiplicity *;
	}
	organization.Person playsRole observers {
		multiplicity *;
	}
}

relation UnitAccountManager {
	organization.Unit playsRole unitForAccountManager {
		multiplicity *;
	}
	organization.Person playsRole accountManager;
}

relation VirtualHostExpenditureTrackingSystem {
	.pt.ist.bennu.core.domain.VirtualHost playsRole virtualHost {
		multiplicity *;
	}
	ExpenditureTrackingSystem playsRole expenditureTrackingSystem {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemAcquisitionCentralGroup {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromAcquisitionCentralGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole acquisitionCentralGroup {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemAcquisitionCentralManagerGroup {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromAcquisitionCentralManagerGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole acquisitionCentralManagerGroup {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemFundCommitmentManagerGroupp {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromFundCommitmentManagerGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole fundCommitmentManagerGroup {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemAccountingManagerGroup {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromAccountingManagerGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole accountingManagerGroup {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemProjectAccountingManagerGroup {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromProjectAccountingManagerGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole projectAccountingManagerGroup {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemTreasuryMemberGroup {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromTreasuryMemberGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole treasuryMemberGroup {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemSupplierManagerGroup {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromSupplierManagerGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole supplierManagerGroup {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemSupplierFundAllocationManagerGroup {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromSupplierFundAllocationManagerGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole supplierFundAllocationManagerGroup {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemStatisticsViewerGroup {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromStatisticsViewerGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole statisticsViewerGroup {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemAcquisitionsUnitManagerGroup {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromAcquisitionsUnitManagerGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole acquisitionsUnitManagerGroup {
		multiplicity 0..1;
	}
}

relation ExpenditureTrackingSystemAcquisitionsProcessAuditorGroup {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromAcquisitionsProcessAuditorGroup {
		multiplicity *;
	}
	.pt.ist.bennu.core.domain.groups.PersistentGroup playsRole acquisitionsProcessAuditorGroup {
		multiplicity 0..1;
	}
}

relation ProjectAcquisitionFundAllocationRequestUnitItem {
	acquisitions.ProjectAcquisitionFundAllocationRequest playsRole projectAcquisitionFundAllocationRequest {
		multiplicity *;
	}
	acquisitions.UnitItem playsRole unitItem {
		multiplicity 0..1;
	}
}

relation AcquisitionFundAllocationDiaryAndTransactionReportRequestFinancer {
	acquisitions.AcquisitionFundAllocationDiaryAndTransactionReportRequest playsRole acquisitionFundAllocationDiaryAndTransactionReportRequest {
		multiplicity *;
	}
	acquisitions.UnitItem playsRole unitItem {
		multiplicity 1..1;
	}
}

relation ExpenditureTrackingSystemOrganizationalAccountabilityType {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromOrganizationalAccountabilityType {
		multiplicity *;
	}
	.module.organization.domain.AccountabilityType playsRole organizationalAccountabilityType;
}

relation ExpenditureTrackingSystemOrganizationalMissionAccountabilityType {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromOrganizationalMissionAccountabilityType {
		multiplicity *;
	}
	.module.organization.domain.AccountabilityType playsRole organizationalMissionAccountabilityType;
}

relation ExpenditureTrackingSystemUnitPartyType {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromUnitPartyType {
		multiplicity *;
	}
	.module.organization.domain.PartyType playsRole unitPartyType;
}

relation ExpenditureTrackingSystemCostCenterPartyType {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromCostCenterPartyType {
		multiplicity *;
	}
	.module.organization.domain.PartyType playsRole costCenterPartyType;
}

relation ExpenditureTrackingSystemProjectPartyType {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromProjectPartyType {
		multiplicity *;
	}
	.module.organization.domain.PartyType playsRole projectPartyType;
}

relation ExpenditureTrackingSystemSubProjectPartyType {
	ExpenditureTrackingSystem playsRole expenditureTrackingSystemFromSubProjectPartyType {
		multiplicity *;
	}
	.module.organization.domain.PartyType playsRole subProjectPartyType;
}