mutation.gql

##
#
# System mutations entrypoint
#
# Conventions for all operations are as follows:
# - input record data is provided in named sub-fields of the request & response
#   - the sub-field ID is the lower camelCase name of the record type
#
# CREATE:
# - fields which are required by the record are required in input parameters
# - optional fields will be left `null` in the record if ommitted
#
# UPDATE:
# - `id` field is required & passing no ID is treated as an error
# - all other fields are optional, if left unchanged they will remain at their
#   current values
# - pass `null` as a field value to erase it
# - when updating array fields, the complete array must be sent; enabling deletion of array elements
# - no fields being updated is treated as a no-op; clients should optimise
#   to avoid unnecessary writes
#
# DELETE:
# - `id` is only parmeter
# - the deleted record will be returned in the response for its fields to be retained
#
# Where there are exceptions to these basic rules, they should be explicitly documented
# in the field description.
#
# :TODO:
# - enable validation of shared core record field presence in C&U operations
#   (@see https://github.com/facebook/graphql/issues/488)
#
##



# Generic parameters

# interface UpdateParams {
#   id: ID!
# }




################################################################################
# Agent module                                                                 #
################################################################################

# interface AgentParams {
#   name: String
#   image: URI
#   primaryLocation: String
#   note: String
# }

input AgentCreateParams { # implements AgentParams
  name: String!
  image: URI
  primaryLocation: ID
  note: String
}

input AgentUpdateParams { # implements UpdateParams & AgentParams
  id: ID!
  name: String
  image: URI
  primaryLocation: ID
  note: String
}

type PersonResponse {
  agent: Person!
}

type OrganizationResponse {
  agent: Organization!
}


# interface AgentRelationshipParams {
#   subject: ID
#   object: ID
#   relationship: ID
#   note: String
# }

input AgentRelationshipCreateParams { # implements AgentRelationshipParams
  subject: ID! # Agent
  object: ID! # Agent
  relationship: ID! # AgentRelationshipRole
  note: String
}

input AgentRelationshipUpdateParams { # implements UpdateParams & AgentRelationshipParams
  id: ID!
  subject: ID
  object: ID
  relationship: ID
  note: String
}

type AgentRelationshipResponse {
  agentRelationship: AgentRelationship!
}






################################################################################
# Observation layer                                                            #
################################################################################

# interface EconomicEventParams {
#   action: ID!
#   inputOf: ID
#   outputOf: ID
#   provider: ID
#   receiver: ID
#   resourceQuantity: IMeasure
#   effortQuantity: IMeasure
#   hasBeginning: DateTime
#   hasEnd: DateTime
#   hasPointInTime: DateTime
#   note: String
#   inScopeOf: [AnyType!]
#   atLocation: ID
#   agreedIn: URI
#   realizationOf: ID # Agreement
#   triggeredBy: ID # EconomicEvent
#   toResourceInventoriedAs: ID # EconomicResource
# }

input EconomicEventCreateParams { # implements EconomicEventParams
  action: ID! # Action
  inputOf: ID # Process
  outputOf: ID # Process
  provider: ID! # Agent
  receiver: ID! # Agent
  inScopeOf: [AnyType!]
  resourceInventoriedAs: ID # EconomicResource
  resourceClassifiedAs: [URI!]
  resourceConformsTo: ID # ResourceSpecification
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  atLocation: ID # SpatialThing
  hasBeginning: DateTime
  hasEnd: DateTime
  hasPointInTime: DateTime
  note: String
  agreedIn: URI
  realizationOf: ID # Agreement
  triggeredBy: ID # EconomicEvent
  toResourceInventoriedAs: ID # EconomicResource
}

input EconomicEventUpdateParams { # implements UpdateParams & EconomicEventParams
  id: ID!
  action: ID
  inputOf: ID
  outputOf: ID
  provider: ID
  receiver: ID
  inScopeOf: [AnyType!]
  resourceInventoriedAs: ID
  resourceClassifiedAs: [URI!]
  resourceConformsTo: ID
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  atLocation: ID # SpatialThing
  hasBeginning: DateTime
  hasEnd: DateTime
  hasPointInTime: DateTime
  note: String
  agreedIn: URI
  realizationOf: ID # Agreement
  triggeredBy: ID # EconomicEvent
  toResourceInventoriedAs: ID # EconomicResource
}

type EconomicEventResponse {
  economicEvent: EconomicEvent!
  economicResource: EconomicResource # only for resource creation events
}


# interface EconomicResourceParams {
#   name: String
#   classifiedAs: [URI!]
#   conformsTo: ID # ResourceSpecification
#   trackingIdentifier: String
#   lot: ID # ProductBatch
#   image: URI # URI
#   accountingQuantity: IMeasure
#   onhandQuantity: IMeasure
#   currentLocation: ID
#   note: String
#   containedIn: ID # EconomicResource
#   unitOfEffort: ID # Unit
#   state: ID # Action
#   stage: ID # ProcessSpecification
# }

"""
Input `EconomicResource` type used when sending events to setup initial resource recordings
"""
input EconomicResourceCreateParams { # implements EconomicResourceParams
  name: String
  conformsTo: ID # ResourceSpecification
  trackingIdentifier: String
  lot: ID # ProductBatch
  image: URI # URI
  containedIn: ID # EconomicResource
  currentLocation: ID # SpatialThing
  note: String
}

input EconomicResourceUpdateParams { # implements UpdateParams & EconomicResourceParams
  id: ID!
  classifiedAs: [URI!]
  image: URI # URI
  containedIn: ID # EconomicResource
  unitOfEffort: ID # Unit
  note: String
}

type EconomicResourceResponse {
  economicResource: EconomicResource!
}


# interface FulfillmentParams {
#   fulfilledBy: ID # EconomicEvent
#   fulfills: ID # Commmitment
#   resourceQuantity: IMeasure
#   effortQuantity: IMeasure
#   note: String
# }

input FulfillmentCreateParams { # implements FulfillmentParams
  fulfilledBy: ID!
  fulfills: ID!
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  note: String
}

input FulfillmentUpdateParams { # implements UpdateParams & FulfillmentParams
  id: ID!
  fulfilledBy: ID
  fulfills: ID
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  note: String
}

type FulfillmentResponse {
  fulfillment: Fulfillment
}


# interface ProcessParams {
#   name: String
#   hasBeginning: DateTime
#   hasEnd: DateTime
#   note: String
#   inScopeOf: String
#   plannedWithin: ID # Plan
#   finished: Boolean
# }

input ProcessCreateParams { # implements ProcessParams
  name: String!
  hasBeginning: DateTime
  hasEnd: DateTime
  finished: Boolean
  note: String
  inScopeOf: [AnyType!]
  plannedWithin: ID # Plan
}

input ProcessUpdateParams { # implements UpdateParams & ProcessParams
  id: ID!
  name: String
  hasBeginning: DateTime
  hasEnd: DateTime
  finished: Boolean
  note: String
  inScopeOf: [AnyType!]
  plannedWithin: ID # Plan
}

type ProcessResponse {
  process: Process
}


# interface AppreciationParams {
#   appreciationOf: ID
#   appreciationWith: ID
#   note: String
# }

input AppreciationCreateParams {
  appreciationOf: ID # EconomicEvent
  appreciationWith: ID # EconomicEvent
  note: String
}

input AppreciationUpdateParams {
  id: ID!
  appreciationOf: ID # EconomicEvent
  appreciationWith: ID # EconomicEvent
  note: String
}

type AppreciationResponse {
  appreciation: Appreciation
}





################################################################################
# Planning layer                                                               #
################################################################################

# interface IntentParams {
#   name: String
#   action: ID
#   inputOf: ID
#   outputOf: ID
#   provider: ID
#   receiver: ID
#   resourceConformsTo: ID
#   resourceClassifiedAs: [URI!]
#   resourceInventoriedAs: ID
#   resourceQuantity: IMeasure
#   effortQuantity: IMeasure
#   availableQuantity: IMeasure
#   hasBeginning: DateTime
#   hasEnd: DateTime
#   hasPointInTime: DateTime
#   due: DateTime
#   image: URI
#   note: String
#   inScopeOf: [AnyType!]
#   atLocation: ID
#   agreedIn: URI
#   finished: Boolean
# }

input IntentCreateParams { # implements IntentParams
  action: ID!
  name: String
  inputOf: ID
  outputOf: ID
  provider: ID
  receiver: ID
  resourceConformsTo: ID
  resourceClassifiedAs: [URI!]
  resourceInventoriedAs: ID
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  availableQuantity: IMeasure
  hasBeginning: DateTime
  hasEnd: DateTime
  hasPointInTime: DateTime
  due: DateTime
  image: URI
  note: String
  inScopeOf: [AnyType!]
  atLocation: ID # SpatialThing
  agreedIn: URI
  finished: Boolean
}

input IntentUpdateParams { # implements UpdateParams & IntentParams
  id: ID!
  name: String
  action: ID
  inputOf: ID
  outputOf: ID
  provider: ID
  receiver: ID
  resourceConformsTo: ID
  resourceClassifiedAs: [URI!]
  resourceInventoriedAs: ID
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  availableQuantity: IMeasure
  hasBeginning: DateTime
  hasEnd: DateTime
  hasPointInTime: DateTime
  due: DateTime
  image: URI
  finished: Boolean
  note: String
  inScopeOf: [AnyType!]
  atLocation: ID # SpatialThing
  agreedIn: URI
}

type IntentResponse {
  intent: Intent!
}


# interface CommitmentParams {
#   action: ID
#   inputOf: ID
#   outputOf: ID
#   provider: ID
#   receiver: ID
#   resourceClassifiedAs: [URI!]
#   resourceConformsTo: ID
#   resourceInventoriedAs: ID
#   resourceQuantity: IMeasure
#   effortQuantity: IMeasure
#   hasBeginning: DateTime
#   hasEnd: DateTime
#   hasPointInTime: DateTime
#   due: DateTime
#   finished: Boolean
#   note: String
#   inScopeOf: [AnyType!]
#   independentDemandOf: ID #Plan
#   atLocation: ID
#   agreedIn: URI
#   clauseOf: Agreement
# }

input CommitmentCreateParams { # implements CommitmentParams
  action: ID!
  inputOf: ID
  outputOf: ID
  provider: ID!
  receiver: ID!
  resourceClassifiedAs: [URI!]
  resourceConformsTo: ID
  resourceInventoriedAs: ID
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  hasBeginning: DateTime
  hasEnd: DateTime
  hasPointInTime: DateTime
  due: DateTime
  finished: Boolean
  note: String
  inScopeOf: [AnyType!]
  independentDemandOf: ID #Plan
  atLocation: ID # SpatialThing
  agreedIn: URI
  clauseOf: ID # Agreement
}

input CommitmentUpdateParams { # implements UpdateParams & CommitmentParams
  id: ID!
  inputOf: ID
  outputOf: ID
  provider: ID
  receiver: ID
  resourceClassifiedAs: [URI!]
  resourceConformsTo: ID
  resourceInventoriedAs: ID
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  hasBeginning: DateTime
  hasEnd: DateTime
  hasPointInTime: DateTime
  due: DateTime
  finished: Boolean
  note: String
  inScopeOf: [AnyType!]
  independentDemandOf: ID #Plan
  atLocation: ID # SpatialThing
  agreedIn: URI
  clauseOf: ID # Agreement
}

type CommitmentResponse {
  commitment: Commitment
}


# interface SatisfactionParams {
#   satisfies: Intent
#   satisfiedBy: Commitment
#   resourceQuantity: IMeasure
#   effortQuantity: IMeasure
#   note: String
# }

input SatisfactionCreateParams { # implements SatisfactionParams
  satisfies: ID! # Intent
  satisfiedBy: ID! # Commitment
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  note: String
}

input SatisfactionUpdateParams { # implements UpdateParams & SatisfactionParams
  id: ID!
  satisfies: ID # Intent
  satisfiedBy: ID # Commitment
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  note: String
}

type SatisfactionResponse {
  satisfaction: Satisfaction
}


# interface AgreementParams {
#   name: String
#   created: DateTime
#   note: String
# }

input AgreementCreateParams { # implements AgreementParams
  name: String!
  created: DateTime!
  note: String
}

input AgreementUpdateParams { # implements UpdateParams & AgreementParams
  id: ID!
  name: String
  created: DateTime
  note: String
}

type AgreementResponse {
  Agreement: Agreement
}


# type ClaimParams {
#   action: Action
#   provider: Agent
#   receiver: Agent
#   resourceClassifiedAs: [URI!]
#   resourceConformsTo: ResourceSpecification
#   resourceQuantity: IMeasure
#   effortQuantity: IMeasure
#   due: DateTime
#   triggeredBy: EconomicEvent!
#   created: DateTime
#   finished: Boolean
#   note: String
#   agreedIn: URI
#   inScopeOf: [AnyType!]
# }

input ClaimCreateParams {
  action: ID! # Action
  provider: ID! # Agent
  receiver: ID! # Agent
  resourceClassifiedAs: [URI!]
  resourceConformsTo: ID # ResourceSpecification
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  due: DateTime
  triggeredBy: ID # EconomicEvent
  created: DateTime
  finished: Boolean
  note: String
  agreedIn: URI
  inScopeOf: [AnyType!]
}

input ClaimUpdateParams {
  id: ID!
  action: ID
  provider: ID
  receiver: ID
  resourceClassifiedAs: [URI!]
  resourceConformsTo: ID
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  due: DateTime
  triggeredBy: ID
  created: DateTime
  finished: Boolean
  note: String
  agreedIn: URI
  inScopeOf: [AnyType!]
}

type ClaimResponse {
  claim: Claim
}


# type SettlementParams {
#   settles: ID! # Claim
#   settledBy: ID! # EconomicEvent
#   resourceQuantity: IMeasure
#   effortQuantity: IMeasure
#   note: String
# }

input SettlementCreateParams {
  settles: ID! # Claim
  settledBy: ID! # EconomicEvent
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  note: String
}

input SettlementUpdateParams {
  id: ID!
  settles: ID
  settledBy: ID
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  note: String
}

type SettlementResponse {
  settlement: Settlement
}


# interface PlanParams {
#   name: String
#   created: DateTime
#   due: DateTime
#   note: String
# }

input PlanCreateParams { # implements PlanParams
  name: String!
  created: DateTime
  due: DateTime
  note: String
}

input PlanUpdateParams { # implements UpdateParams & PlanParams
  id: ID!
  name: String
  created: DateTime
  due: DateTime
  note: String
}

type PlanResponse {
  plan: Plan
}


# interface ScenarioParams {
#   name: String
#   definedAs: ScenarioDefinition
#   hasBeginning: DateTime
#   hasEnd: DateTime
#   inScopeOf: [AnyType!]
#   note: String
# }

input ScenarioCreateParams { # implements ScenarioParams
  name: String!
  definedAs: ID! #ScenarioDefinition
  hasBeginning: DateTime
  hasEnd: DateTime
  inScopeOf: [AnyType!]
  note: String
}

input ScenarioUpdateParams { # implements UpdateParams & ScenarioParams
  id: ID!
  name: String
  definedAs: ID! #ScenarioDefinition
  hasBeginning: DateTime
  hasEnd: DateTime
  inScopeOf: [AnyType!]
  note: String
}

type ScenarioResponse {
  scenario: Scenario
}




################################################################################
# Knowledge layer
################################################################################


# interface UnitParams {
#   label: String
#   symbol: String
# }

input UnitCreateParams { # implements UnitParams
  label: String!
  symbol: String!
}

input UnitUpdateParams { # implements UpdateParams & UnitParams
  id: ID!
  label: String
  symbol: String
}

type UnitResponse {
  unit: Unit
}


# interface ResourceSpecificationParams {
#   name: String
#   image: URI
#   note: String
# }

input ResourceSpecificationCreateParams { # implements ResourceSpecificationParams
  name: String!
  image: URI
  note: String
}

input ResourceSpecificationUpdateParams { # implements UpdateParams & ResourceSpecificationParams
  id: ID!
  name: String
  image: URI
  note: String
}

type ResourceSpecificationResponse {
  resourceSpecification: ResourceSpecification
}


# interface ProcessSpecificationParams {
#   name: String
#   note: String
# }

input ProcessSpecificationCreateParams { # implements ProcessSpecificationParams
  name: String!
  note: String
}

input ProcessSpecificationUpdateParams { # implements UpdateParams & ProcessSpecificationParams
  id: ID!
  name: String
  note: String
}

type ProcessSpecificationResponse {
  processSpecification: ProcessSpecification
}

# interface RecipeResourceParams {
#   name: String
#   image: URI
#   unitOfResource: ID
#   unitOfEffort: ID
#   resourceClassifiedAs: [URI!]
#   substitutable: Boolean
#   note: String
# }

input RecipeResourceCreateParams { # implements RecipeResourceParams
  name: String!
  unitOfResource: ID
  unitOfEffort: ID
  substitutable: Boolean
  image: URI
  resourceClassifiedAs: [URI!]
  note: String
}

input RecipeResourceUpdateParams { # implements UpdateParams & RecipeResourceParams
  id: ID!
  name: String
  unitOfResource: ID
  unitOfEffort: ID
  substitutable: Boolean
  image: URI
  resourceClassifiedAs: [URI!]
  note: String
}

type RecipeResourceResponse {
  recipeResource: RecipeResource
}


# interface RecipeProcessParams {
#   name: String
#   hasDuration: IDuration
#   processClassifiedAs: [URI!]
#   note: String
# }

input RecipeProcessCreateParams { # implements RecipeProcessParams
  name: String!
  hasDuration: IDuration
  processClassifiedAs: [URI!]
  note: String
}

input RecipeProcessUpdateParams { # implements UpdateParams & RecipeProcessParams
  id: ID!
  name: String
  hasDuration: IDuration
  processClassifiedAs: [URI!]
  note: String
}

type RecipeProcessResponse {
  recipeProcess: RecipeProcess
}


# interface RecipeFlowParams {
#   action: Action
#   recipeFlowResource: RecipeResource
#   resourceQuantity: IMeasure
#   effortQuantity: IMeasure
#   recipeInputOf: RecipeProcess
#   recipeOutputOf: RecipeProcess
#   stage: ProcessSpecification
#   state: Action
#   note: String
# }

input RecipeFlowCreateParams { # implements RecipeFlowParams
  action: ID! # Action
  recipeFlowResource: ID # RecipeResource!
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  recipeInputOf: ID # RecipeProcess
  recipeOutputOf: ID # RecipeProcess
  stage: ID # ProcessSpecification
  state: ID # Action
  note: String
}

input RecipeFlowUpdateParams { # implements UpdateParams & RecipeFlowParams
  id: ID!
  action: ID # Action
  recipeFlowResource: ID # RecipeResource
  resourceQuantity: IMeasure
  effortQuantity: IMeasure
  recipeInputOf: ID # RecipeProcess
  recipeOutputOf: ID # RecipeProcess
  stage: ID # ProcessSpecification
  state: ID # Action
  note: String
}

type RecipeFlowResponse {
  recipeFlow: RecipeFlow
}


# interface AgentRelationshipRoleParams {
#   roleLabel: String
#   inverseRoleLabel: String
#   note: String
# }

input AgentRelationshipRoleCreateParams { # implements AgentRelationshipRoleParams
  roleLabel: String!
  inverseRoleLabel: String
  note: String
}

input AgentRelationshipRoleUpdateParams { # implements UpdateParams & AgentRelationshipRoleParams
  id: ID!
  roleLabel: String
  inverseRoleLabel: String
  note: String
}

type AgentRelationshipRoleResponse {
  agentRelationshipRole: AgentRelationshipRole
}



# interface ScenarioDefinitionParams {
#   name: String
#   hasDuration: IDuration
#   note: String
# }

input ScenarioDefinitionCreateParams { # implements ScenarioDefinitionParams
  name: String
  hasDuration: IDuration
  note: String
}

input ScenarioDefinitionUpdateParams { # implements UpdateParams & ScenarioDefinitionParams
  id: ID!
  hasDuration: IDuration
  note: String
}

type ScenarioDefinitionResponse {
  scenarioDefinition: ScenarioDefinition
}

##########################################################
# Proposal layer                                         #
##########################################################


input ProposalCreateParams{
  name: String
  hasBeginning: DateTime
  hasEnd: DateTime
  inScopeOf: [AnyType!]
  unitBased: Boolean
  created: DateTime
  note: String
}

input ProposalUpdateParams{
  id: ID!
  name: String
  hasBeginning: DateTime
  hasEnd: DateTime
  inScopeOf: [AnyType!]
  unitBased: Boolean
  created: DateTime
  note: String
}

type ProposalResponse{
  proposal: Proposal
}

input ProposedToCreateParams{
  proposedTo: Agent!
}

input ProposedToUpdateParams{
  id: ID!
  proposedTo: Agent!
}

type ProposedToResponse{
  proposedTo: ProposedTo
}

input ProposedIntentCreateParams{
  reciprocal: Boolean
}

input ProposedIntentUpdateParams{
  id: ID!
  reciprocal: Boolean
}

type ProposedIntentResponse{
  proposedIntent: ProposedIntent
}

################################################################################
# MAIN MUTATIONS ENTRYPOINT                                                    #
################################################################################

type Mutation {

  # Agent module

  createPerson(person: AgentCreateParams!): PersonResponse
  updatePerson(person: AgentUpdateParams!): PersonResponse
  deletePerson(id: String!): Boolean

  createOrganization(organization: AgentCreateParams!): OrganizationResponse
  updateOrganization(organization: AgentUpdateParams!): OrganizationResponse
  deleteOrganization(id: String!): Boolean

  createAgentRelationship(relationship: AgentRelationshipCreateParams!): AgentRelationshipResponse
  updateAgentRelationship(relationship: AgentRelationshipUpdateParams!): AgentRelationshipResponse
  deleteAgentRelationship(id: String!): Boolean

  createAgentRelationshipRole(agentRelationshipRole: AgentRelationshipRoleCreateParams): AgentRelationshipRoleResponse
  updateAgentRelationshipRole(agentRelationshipRole: AgentRelationshipRoleUpdateParams): AgentRelationshipRoleResponse
  deleteAgentRelationshipRole(id: String!): Boolean

  # Observation layer

  createEconomicEvent(event: EconomicEventCreateParams!, newInventoriedResource: EconomicResourceCreateParams): EconomicEventResponse
  updateEconomicEvent(event: EconomicEventUpdateParams!): EconomicEventResponse
  deleteEconomicEvent(id: String!): Boolean

  # :TODO: should this be allowed without an originating event? Or should the event be recorded transparently?
  updateEconomicResource(resource: EconomicResourceUpdateParams!): EconomicResourceResponse
  deleteEconomicResource(id: String!): Boolean

  #createValidation(note: String, economicEvent: String!, validatedBy: String!): CreateValidation
  #deleteValidation(id: String!): DeleteValidation

  createProcess(process: ProcessCreateParams!): ProcessResponse
  updateProcess(process: ProcessUpdateParams!): ProcessResponse
  deleteProcess(id: String!): Boolean

  createAppreciation(appreciation: AppreciationCreateParams!): AppreciationResponse
  updateAppreciation(appreciation: AppreciationUpdateParams!): AppreciationResponse
  deleteAppreciation(id: String!): Boolean

  # Planning layer

  createCommitment(commitment: CommitmentCreateParams): CommitmentResponse
  updateCommitment(commitment: CommitmentUpdateParams): CommitmentResponse
  deleteCommitment(id: String!): Boolean

  createIntent(intent: IntentCreateParams): IntentResponse
  updateIntent(intent: IntentUpdateParams): IntentResponse
  deleteIntent(id: String!): Boolean

  createFulfillment(fulfillment: FulfillmentCreateParams!): FulfillmentResponse
  updateFulfillment(fulfillment: FulfillmentUpdateParams!): FulfillmentResponse
  deleteFulfillment(id: String!): Boolean

  createSatisfaction(satisfaction: SatisfactionCreateParams): SatisfactionResponse
  updateSatisfaction(satisfaction: SatisfactionUpdateParams): SatisfactionResponse # TODO: add EconomicEvent
  deleteSatisfaction(id: String!): Boolean

  # Proposal layer

  createProposal(proposal: ProposalCreateParams): ProposalResponse
  updateProposal(proposal: ProposalUpdateParams): ProposalResponse
  deleteProposal(id: String!): Boolean

  createProposedTo(proposedTo: ProposedToCreateParams): ProposedToResponse
  updateProposedTo(proposedTo: ProposedToUpdateParams): ProposedToResponse
  deleteProposedTo(id: String!): Boolean

  createProposedIntent(proposedIntent: ProposedIntentCreateParams): ProposedIntentResponse
  updateProposedIntent(proposedIntent: ProposedIntentUpdateParams): ProposedIntentResponse
  deleteProposedIntent(id: String!): Boolean

  createPlan(plan: PlanCreateParams!): PlanResponse
  # createPlanFromRecipe(): PlanResponse
  updatePlan(plan: PlanUpdateParams!): PlanResponse
  deletePlan(id: String!): Boolean

  createScenario(plan: ScenarioCreateParams!): ScenarioResponse
  updateScenario(plan: ScenarioUpdateParams!): ScenarioResponse
  deleteScenario(id: String!): Boolean

  createAgreement(agreement: AgreementCreateParams): AgreementResponse
  updateAgreement(agreement: AgreementUpdateParams): AgreementResponse
  deleteAgreement(id: String!): Boolean

  createClaim(claim: ClaimCreateParams!): ClaimResponse
  updateClaim(claim: ClaimUpdateParams!): ClaimResponse
  deleteClaim(id: String!): Boolean

  createSettlement(settlement: SettlementCreateParams!): SettlementResponse
  updateSettlement(s0ettlement: SettlementUpdateParams!): SettlementResponse
  deleteSettlement(id: String!): Boolean

  # Knowledge layer

  #createAgentResourceClassification(resourceClassification: String!, agent: String!): CreateAgentResourceClassification
  #deleteAgentResourceClassification(id: String!): DeleteAgentResourceClassification

  createUnit(unit: UnitCreateParams): UnitResponse
  updateUnit(unit: UnitUpdateParams): UnitResponse
  deleteUnit(id: String!): Boolean

  createResourceSpecification(resourceSpecification: ResourceSpecificationCreateParams): ResourceSpecificationResponse
  updateResourceSpecification(resourceSpecification: ResourceSpecificationUpdateParams): ResourceSpecificationResponse
  deleteResourceSpecification(id: String!): Boolean

  createProcessSpecification(processSpecification: ProcessSpecificationCreateParams): ProcessSpecificationResponse
  updateProcessSpecification(processSpecification: ProcessSpecificationUpdateParams): ProcessSpecificationResponse
  deleteProcessSpecification(id: String!): Boolean

  createRecipeFlow(recipeFlow: RecipeFlowCreateParams): RecipeFlowResponse
  updateRecipeFlow(recipeFlow: RecipeFlowUpdateParams): RecipeFlowResponse
  deleteRecipeFlow(id: String!): Boolean

  createRecipeProcess(recipeProcess: RecipeProcessCreateParams): RecipeProcessResponse
  updateRecipeProcess(recipeProcess: RecipeProcessUpdateParams): RecipeProcessResponse
  deleteRecipeProcess(id: String!): Boolean
}