type Focus is view[focus_name : String, focus_params : sequence[String]];
type Foci is sequense[Focus];
type SenseRequest is view[agent_id : String, foci : Foci];
type Representation is any;
type Action is view[agent_id : String, action_name : String, action_params : sequence[String]];
type Message is view[ID : Integer, sender : String, receiver : String, performative : String, content : String]; 
type StateItem is view[name : String, val : any]; 
type StateItems is sequense[KnowledgeItem]; 
type Operation is any;
type Observation is any; 
type SynchronizationMessage is any; 
type Transmission is any; 

value Virtual_Environment is abstraction ()
{
	//external interfaces
	Sense_Request : Connection[SenseRequest];
	Sense_Result : Connection[Representation];
	Act : Connection[Action];
	Send_Receive : Connection[Message];
	Operate : Connection[Operation]; 
	Synchronize : Connection[SynchronizationMessage]; 
	Observe : Connection[Observation];
	Transmit_Deliver : Connection[Transmission]; 

	//exchanged data
	sense_request : SenseRequest;
	sense_result : Representation;
	action : Action;
	message_in : Message; 
	message_out : Message; 
	state_item : StateItem; 
	operation : Operation;
	sync_requets : SynchronizationMessage;
	sync_update : SynchronizationMessage;
	observation_request : Observation;
	observation_result : Observation;
	transmit_msg : Transmission; 
	deliver_msg : Transmission;

	//connections among the components
	C_Read_Write : Connection[StateItems];

	//component composition
	compose
	{
		via CommunicationService send Void where {
			Send_Receive renames Send_Receive,
			C_Read_Write renames Read_Write, 
			Transmit_Deliver renames Transmit_Deliver};
	and   via ActionService send Void where {
			Act renames Act, 
			C_Read_Write renames Read_Write, 
			Operate renames Operate};
	and   via PerceptionService send Void where {
			Sense_Request renames Sense_Request,
			Sense_Result renames Sense_Result, 
			C_Read_Write renames Read_Write, 
			Observe renames Observe};
	and
		via State send Void where {
			C_Read_Write renames Read_Write};
	and	
		via Dynamics send Void where {
			C_Read_Write renames Read_Write};
	and 
		via Synchronization send Void where {
			C_Read_Write renames Read_Write,
			Synchronize renames Synchronize};
	}
}

value CommunicationService is abstraction ()
{
	Send_Receive : Connection[Message];
	Transmit_Deliver : Connection[Transmission];
	Read_Write : Connection[StateItems];

	message_in : Message;
	message_out : Message;
	state_items : StateItems; 
	deliver_in : Transmission;
	transmit_out : Transmission;

	choose 
	{
		//send message 
		via Send_Receive receive message_out;
		unobservable;
		via Transmit_Deliver send transmit_out;
	or
		//deliver message
		via Transmit_Deliver receive deliver_in;
		unobservable;
		via Send_Receive send message_in;
	}
}

value ActionService is abstraction ()
{
	Act : Connection[Action];
	Operate : Connection[Operations];
	Read_Write : Connection[StateItems];

	action : Action;
	state_items : StateItems; 
	operation : Operation;

	via Act receive action; 
	choose 
	{
		//state update
		unobservable;
	or
		//operation
		unobservable;
		via Operate send operation;
	}
}

value PerceptionService is abstraction ()
{
	Sense_Request : Connection[SenseRequest];
	Sense_Result : Connection[Representation];
	Observe : Connection[Observation];
	Read_Write : Connection[StateItems];

	sense_request : SenseRequest;
	sense_result : Representation;
	state_items : StateItems; 
	observation_request : Observation;
	observation_result : Observation;

	via Sense_Request receive sense_request; 
	choose 
	{
		//read state repository
		unobservable;
		via Sense_Result send sense_result; 
		
	or
		//observation
		unobservable;
		via Observe send observation_request;
		unobservable; 
		via Observe receive observation_result; 
		unobservable;
		via Sense_Result send sense_result; 
	}
}


value State is abstraction ()
{
	Read_Write : Connection[StateItems];
	
	read_request : StateItems;
	read_item : StateItems; 
	write_item : StateItems; 
	
	replicate 
	{
		choose 
		{
			//read item
			via Read_Write receive read_request;
			unobservable;
			via Read_Write send read_item;
		or 
	  		//write item
			via Read_Write receive write_item;
			unobservable;
		}
	}
}

value Dynamics is abstraction ()
{
	Read_Write : Connection[StateItems];
	
	read_request : StateItems;
	read_item : StateItems; 
	write_item : StateItems; 
	
	replicate 
	{
		via Read_Write send read_request;
		unobservable;
		via Read_Write receive read_item;
		unobservable;
		via Read_Write send write_item;
	}
}

value Synchronization is abstraction ()
{
	Read_Write : Connection[StateItems];
	Synchronize : Connection[SynchronizationMessage];
	
	read_request : StateItems;
	read_item : StateItems; 
	write_item : StateItems; 
	sync_request : SynchronizationMessage;
	sync_update : SynchronizationMessage;
	
	replicate
	{
		choose
		{
			//send synchronization request
			unobservable;
			via Synchronize send sync_request;
		or
			via Synchronize receive sync_update; 
			unobservable; 
			
		}
	}
}