use std::time::Duration;
use chrono::prelude::*;
use derive_builder::Builder;
use getset::Getters;
use getset::Setters;
use getset::MutGetters;
use serde_derive::{Serialize, Deserialize};
use url::Url;
pub mod dfc {
use super::*;
mod product_batch {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct ProductBatch {
batch_number: String,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
expiry_date: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
production_date: Option<DateTime<Utc>>,
}
impl ProductBatch {
#[allow(dead_code)]
pub fn builder() -> ProductBatchBuilder {
ProductBatchBuilder {
batch_number: None,
expiry_date: None,
production_date: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> ProductBatchBuilder {
let ProductBatch { batch_number, expiry_date, production_date } = self;
let mut builder = Self::builder();
builder = builder.batch_number(batch_number);
builder = match expiry_date { Some(x) => builder.expiry_date(x), None => builder };
builder = match production_date { Some(x) => builder.production_date(x), None => builder };
builder
}
}
}
pub use product_batch::ProductBatch;
pub mod builders {
pub use super::product_batch::ProductBatchBuilder;
}
}
pub mod geo {
use super::*;
mod spatial_thing {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct SpatialThing {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
alt: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
lat: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
long: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
mappable_address: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
}
impl SpatialThing {
#[allow(dead_code)]
pub fn builder() -> SpatialThingBuilder {
SpatialThingBuilder {
alt: None,
lat: None,
long: None,
mappable_address: None,
name: None,
note: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> SpatialThingBuilder {
let SpatialThing { alt, lat, long, mappable_address, name, note } = self;
let mut builder = Self::builder();
builder = match alt { Some(x) => builder.alt(x), None => builder };
builder = match lat { Some(x) => builder.lat(x), None => builder };
builder = match long { Some(x) => builder.long(x), None => builder };
builder = match mappable_address { Some(x) => builder.mappable_address(x), None => builder };
builder = match name { Some(x) => builder.name(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder
}
}
}
pub use spatial_thing::SpatialThing;
pub mod builders {
pub use super::spatial_thing::SpatialThingBuilder;
}
}
pub mod vf {
use super::*;
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub enum CommitmentEconomicEventUnion<COMMITMENT, ECONOMICEVENT> {
Commitment(COMMITMENT),
EconomicEvent(ECONOMICEVENT),
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub enum Action {
#[serde(rename = "accept")]
Accept,
#[serde(rename = "cite")]
Cite,
#[serde(rename = "consume")]
Consume,
#[serde(rename = "deliver-service")]
DeliverService,
#[serde(rename = "dropoff")]
Dropoff,
#[serde(rename = "lower")]
Lower,
#[serde(rename = "modify")]
Modify,
#[serde(rename = "move")]
Move,
#[serde(rename = "pickup")]
Pickup,
#[serde(rename = "produce")]
Produce,
#[serde(rename = "raise")]
Raise,
#[serde(rename = "transfer")]
Transfer,
#[serde(rename = "transfer-all-rights")]
TransferAllRights,
#[serde(rename = "transfer-custody")]
TransferCustody,
#[serde(rename = "use")]
Use,
#[serde(rename = "work")]
Work,
}
impl Action {
#[allow(dead_code)]
pub fn input_output(&self) -> Option<InputOutput> {
match self {
Self::Accept => Some(InputOutput::Input),
Self::Cite => Some(InputOutput::Input),
Self::Consume => Some(InputOutput::Input),
Self::DeliverService => Some(InputOutput::Output),
Self::Dropoff => Some(InputOutput::Output),
Self::Modify => Some(InputOutput::Output),
Self::Pickup => Some(InputOutput::Input),
Self::Produce => Some(InputOutput::Output),
Self::Use => Some(InputOutput::Input),
Self::Work => Some(InputOutput::Input),
_ => None,
}
}
#[allow(dead_code)]
pub fn pairs_with(&self) -> Option<Action> {
match self {
Self::Accept => Some(Action::Modify),
Self::Dropoff => Some(Action::Pickup),
Self::Modify => Some(Action::Accept),
Self::Pickup => Some(Action::Dropoff),
_ => None,
}
}
#[allow(dead_code)]
pub fn resource_effect(&self) -> ResourceEffect {
match self {
Self::Accept => ResourceEffect::NoEffect,
Self::Cite => ResourceEffect::NoEffect,
Self::Consume => ResourceEffect::Decrement,
Self::DeliverService => ResourceEffect::NoEffect,
Self::Dropoff => ResourceEffect::NoEffect,
Self::Lower => ResourceEffect::Decrement,
Self::Modify => ResourceEffect::NoEffect,
Self::Move => ResourceEffect::DecrementIncrement,
Self::Pickup => ResourceEffect::NoEffect,
Self::Produce => ResourceEffect::Increment,
Self::Raise => ResourceEffect::Increment,
Self::Transfer => ResourceEffect::DecrementIncrement,
Self::TransferAllRights => ResourceEffect::DecrementIncrement,
Self::TransferCustody => ResourceEffect::DecrementIncrement,
Self::Use => ResourceEffect::NoEffect,
Self::Work => ResourceEffect::NoEffect,
}
}
}
mod agent {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Agent {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
image: Option<Url>,
name: String,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
primary_location: Option<geo::SpatialThing>,
}
impl Agent {
#[allow(dead_code)]
pub fn builder() -> AgentBuilder {
AgentBuilder {
image: None,
name: None,
note: None,
primary_location: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> AgentBuilder {
let Agent { image, name, note, primary_location } = self;
let mut builder = Self::builder();
builder = match image { Some(x) => builder.image(x), None => builder };
builder = builder.name(name);
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match primary_location { Some(x) => builder.primary_location(x), None => builder };
builder
}
}
}
pub use agent::Agent;
mod agent_relationship {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct AgentRelationship<AGENT, AGENTRELATIONSHIPROLE> {
#[builder(default)]
in_scope_of: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
object: AGENT,
relationship: AGENTRELATIONSHIPROLE,
subject: AGENT,
}
impl<AGENT, AGENTRELATIONSHIPROLE> AgentRelationship<AGENT, AGENTRELATIONSHIPROLE> {
#[allow(dead_code)]
pub fn builder() -> AgentRelationshipBuilder<AGENT, AGENTRELATIONSHIPROLE> {
AgentRelationshipBuilder {
in_scope_of: None,
note: None,
object: None,
relationship: None,
subject: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> AgentRelationshipBuilder<AGENT, AGENTRELATIONSHIPROLE> {
let AgentRelationship { in_scope_of, note, object, relationship, subject } = self;
let mut builder = Self::builder();
builder = builder.in_scope_of(in_scope_of);
builder = match note { Some(x) => builder.note(x), None => builder };
builder = builder.object(object);
builder = builder.relationship(relationship);
builder = builder.subject(subject);
builder
}
}
}
pub use agent_relationship::AgentRelationship;
mod agent_relationship_role {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct AgentRelationshipRole {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
inverse_role_label: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
role_label: String,
}
impl AgentRelationshipRole {
#[allow(dead_code)]
pub fn builder() -> AgentRelationshipRoleBuilder {
AgentRelationshipRoleBuilder {
inverse_role_label: None,
note: None,
role_label: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> AgentRelationshipRoleBuilder {
let AgentRelationshipRole { inverse_role_label, note, role_label } = self;
let mut builder = Self::builder();
builder = match inverse_role_label { Some(x) => builder.inverse_role_label(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = builder.role_label(role_label);
builder
}
}
}
pub use agent_relationship_role::AgentRelationshipRole;
mod agreement {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Agreement {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
created: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
}
impl Agreement {
#[allow(dead_code)]
pub fn builder() -> AgreementBuilder {
AgreementBuilder {
created: None,
name: None,
note: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> AgreementBuilder {
let Agreement { created, name, note } = self;
let mut builder = Self::builder();
builder = match created { Some(x) => builder.created(x), None => builder };
builder = match name { Some(x) => builder.name(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder
}
}
}
pub use agreement::Agreement;
mod appreciation {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Appreciation<ECONOMICEVENT> {
appreciation_of: ECONOMICEVENT,
appreciation_with: ECONOMICEVENT,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
}
impl<ECONOMICEVENT> Appreciation<ECONOMICEVENT> {
#[allow(dead_code)]
pub fn builder() -> AppreciationBuilder<ECONOMICEVENT> {
AppreciationBuilder {
appreciation_of: None,
appreciation_with: None,
note: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> AppreciationBuilder<ECONOMICEVENT> {
let Appreciation { appreciation_of, appreciation_with, note } = self;
let mut builder = Self::builder();
builder = builder.appreciation_of(appreciation_of);
builder = builder.appreciation_with(appreciation_with);
builder = match note { Some(x) => builder.note(x), None => builder };
builder
}
}
}
pub use appreciation::Appreciation;
mod claim {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Claim<AGENT, RESOURCESPECIFICATION, ECONOMICEVENT> {
action: Action,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
agreed_in: Option<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
created: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
due: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
effort_quantity: Option<om2::Measure>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
finished: Option<bool>,
#[builder(default)]
in_scope_of: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
provider: AGENT,
receiver: AGENT,
#[builder(default)]
resource_classified_as: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_conforms_to: Option<RESOURCESPECIFICATION>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_quantity: Option<om2::Measure>,
triggered_by: ECONOMICEVENT,
}
impl<AGENT, RESOURCESPECIFICATION, ECONOMICEVENT> Claim<AGENT, RESOURCESPECIFICATION, ECONOMICEVENT> {
#[allow(dead_code)]
pub fn builder() -> ClaimBuilder<AGENT, RESOURCESPECIFICATION, ECONOMICEVENT> {
ClaimBuilder {
action: None,
agreed_in: None,
created: None,
due: None,
effort_quantity: None,
finished: None,
in_scope_of: None,
note: None,
provider: None,
receiver: None,
resource_classified_as: None,
resource_conforms_to: None,
resource_quantity: None,
triggered_by: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> ClaimBuilder<AGENT, RESOURCESPECIFICATION, ECONOMICEVENT> {
let Claim { action, agreed_in, created, due, effort_quantity, finished, in_scope_of, note, provider, receiver, resource_classified_as, resource_conforms_to, resource_quantity, triggered_by } = self;
let mut builder = Self::builder();
builder = builder.action(action);
builder = match agreed_in { Some(x) => builder.agreed_in(x), None => builder };
builder = match created { Some(x) => builder.created(x), None => builder };
builder = match due { Some(x) => builder.due(x), None => builder };
builder = match effort_quantity { Some(x) => builder.effort_quantity(x), None => builder };
builder = match finished { Some(x) => builder.finished(x), None => builder };
builder = builder.in_scope_of(in_scope_of);
builder = match note { Some(x) => builder.note(x), None => builder };
builder = builder.provider(provider);
builder = builder.receiver(receiver);
builder = builder.resource_classified_as(resource_classified_as);
builder = match resource_conforms_to { Some(x) => builder.resource_conforms_to(x), None => builder };
builder = match resource_quantity { Some(x) => builder.resource_quantity(x), None => builder };
builder = builder.triggered_by(triggered_by);
builder
}
}
}
pub use claim::Claim;
mod commitment {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Commitment<AGREEMENT, PLAN, PROCESS, AGENT, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
action: Action,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
agreed_in: Option<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
at_location: Option<geo::SpatialThing>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
clause_of: Option<AGREEMENT>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
created: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
due: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
effort_quantity: Option<om2::Measure>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
finished: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_beginning: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_end: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_point_in_time: Option<DateTime<Utc>>,
#[builder(default)]
in_scope_of: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
independent_demand_of: Option<PLAN>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
input_of: Option<PROCESS>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
output_of: Option<PROCESS>,
provider: AGENT,
receiver: AGENT,
#[builder(default)]
resource_classified_as: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_conforms_to: Option<RESOURCESPECIFICATION>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_inventoried_as: Option<ECONOMICRESOURCE>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_quantity: Option<om2::Measure>,
}
impl<AGREEMENT, PLAN, PROCESS, AGENT, RESOURCESPECIFICATION, ECONOMICRESOURCE> Commitment<AGREEMENT, PLAN, PROCESS, AGENT, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
#[allow(dead_code)]
pub fn builder() -> CommitmentBuilder<AGREEMENT, PLAN, PROCESS, AGENT, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
CommitmentBuilder {
action: None,
agreed_in: None,
at_location: None,
clause_of: None,
created: None,
due: None,
effort_quantity: None,
finished: None,
has_beginning: None,
has_end: None,
has_point_in_time: None,
in_scope_of: None,
independent_demand_of: None,
input_of: None,
name: None,
note: None,
output_of: None,
provider: None,
receiver: None,
resource_classified_as: None,
resource_conforms_to: None,
resource_inventoried_as: None,
resource_quantity: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> CommitmentBuilder<AGREEMENT, PLAN, PROCESS, AGENT, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
let Commitment { action, agreed_in, at_location, clause_of, created, due, effort_quantity, finished, has_beginning, has_end, has_point_in_time, in_scope_of, independent_demand_of, input_of, name, note, output_of, provider, receiver, resource_classified_as, resource_conforms_to, resource_inventoried_as, resource_quantity } = self;
let mut builder = Self::builder();
builder = builder.action(action);
builder = match agreed_in { Some(x) => builder.agreed_in(x), None => builder };
builder = match at_location { Some(x) => builder.at_location(x), None => builder };
builder = match clause_of { Some(x) => builder.clause_of(x), None => builder };
builder = match created { Some(x) => builder.created(x), None => builder };
builder = match due { Some(x) => builder.due(x), None => builder };
builder = match effort_quantity { Some(x) => builder.effort_quantity(x), None => builder };
builder = match finished { Some(x) => builder.finished(x), None => builder };
builder = match has_beginning { Some(x) => builder.has_beginning(x), None => builder };
builder = match has_end { Some(x) => builder.has_end(x), None => builder };
builder = match has_point_in_time { Some(x) => builder.has_point_in_time(x), None => builder };
builder = builder.in_scope_of(in_scope_of);
builder = match independent_demand_of { Some(x) => builder.independent_demand_of(x), None => builder };
builder = match input_of { Some(x) => builder.input_of(x), None => builder };
builder = match name { Some(x) => builder.name(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match output_of { Some(x) => builder.output_of(x), None => builder };
builder = builder.provider(provider);
builder = builder.receiver(receiver);
builder = builder.resource_classified_as(resource_classified_as);
builder = match resource_conforms_to { Some(x) => builder.resource_conforms_to(x), None => builder };
builder = match resource_inventoried_as { Some(x) => builder.resource_inventoried_as(x), None => builder };
builder = match resource_quantity { Some(x) => builder.resource_quantity(x), None => builder };
builder
}
}
}
pub use commitment::Commitment;
mod economic_event {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct EconomicEvent<PROCESS, AGENT, AGREEMENT, RESOURCESPECIFICATION, ECONOMICRESOURCE, ECONOMICEVENT> {
action: Action,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
agreed_in: Option<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
at_location: Option<geo::SpatialThing>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
effort_quantity: Option<om2::Measure>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_beginning: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_end: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_point_in_time: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
image: Option<Url>,
#[builder(default)]
in_scope_of: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
input_of: Option<PROCESS>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
output_of: Option<PROCESS>,
provider: AGENT,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
realization_of: Option<AGREEMENT>,
receiver: AGENT,
#[builder(default)]
resource_classified_as: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_conforms_to: Option<RESOURCESPECIFICATION>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_inventoried_as: Option<ECONOMICRESOURCE>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_quantity: Option<om2::Measure>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
to_resource_inventoried_as: Option<ECONOMICRESOURCE>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
triggered_by: Option<ECONOMICEVENT>,
}
impl<PROCESS, AGENT, AGREEMENT, RESOURCESPECIFICATION, ECONOMICRESOURCE, ECONOMICEVENT> EconomicEvent<PROCESS, AGENT, AGREEMENT, RESOURCESPECIFICATION, ECONOMICRESOURCE, ECONOMICEVENT> {
#[allow(dead_code)]
pub fn builder() -> EconomicEventBuilder<PROCESS, AGENT, AGREEMENT, RESOURCESPECIFICATION, ECONOMICRESOURCE, ECONOMICEVENT> {
EconomicEventBuilder {
action: None,
agreed_in: None,
at_location: None,
effort_quantity: None,
has_beginning: None,
has_end: None,
has_point_in_time: None,
image: None,
in_scope_of: None,
input_of: None,
note: None,
output_of: None,
provider: None,
realization_of: None,
receiver: None,
resource_classified_as: None,
resource_conforms_to: None,
resource_inventoried_as: None,
resource_quantity: None,
to_resource_inventoried_as: None,
triggered_by: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> EconomicEventBuilder<PROCESS, AGENT, AGREEMENT, RESOURCESPECIFICATION, ECONOMICRESOURCE, ECONOMICEVENT> {
let EconomicEvent { action, agreed_in, at_location, effort_quantity, has_beginning, has_end, has_point_in_time, image, in_scope_of, input_of, note, output_of, provider, realization_of, receiver, resource_classified_as, resource_conforms_to, resource_inventoried_as, resource_quantity, to_resource_inventoried_as, triggered_by } = self;
let mut builder = Self::builder();
builder = builder.action(action);
builder = match agreed_in { Some(x) => builder.agreed_in(x), None => builder };
builder = match at_location { Some(x) => builder.at_location(x), None => builder };
builder = match effort_quantity { Some(x) => builder.effort_quantity(x), None => builder };
builder = match has_beginning { Some(x) => builder.has_beginning(x), None => builder };
builder = match has_end { Some(x) => builder.has_end(x), None => builder };
builder = match has_point_in_time { Some(x) => builder.has_point_in_time(x), None => builder };
builder = match image { Some(x) => builder.image(x), None => builder };
builder = builder.in_scope_of(in_scope_of);
builder = match input_of { Some(x) => builder.input_of(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match output_of { Some(x) => builder.output_of(x), None => builder };
builder = builder.provider(provider);
builder = match realization_of { Some(x) => builder.realization_of(x), None => builder };
builder = builder.receiver(receiver);
builder = builder.resource_classified_as(resource_classified_as);
builder = match resource_conforms_to { Some(x) => builder.resource_conforms_to(x), None => builder };
builder = match resource_inventoried_as { Some(x) => builder.resource_inventoried_as(x), None => builder };
builder = match resource_quantity { Some(x) => builder.resource_quantity(x), None => builder };
builder = match to_resource_inventoried_as { Some(x) => builder.to_resource_inventoried_as(x), None => builder };
builder = match triggered_by { Some(x) => builder.triggered_by(x), None => builder };
builder
}
}
}
pub use economic_event::EconomicEvent;
mod economic_resource {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct EconomicResource<RESOURCESPECIFICATION, ECONOMICRESOURCE, AGENT, PROCESSSPECIFICATION> {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
accounting_quantity: Option<om2::Measure>,
#[builder(default)]
classified_as: Vec<Url>,
conforms_to: RESOURCESPECIFICATION,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
contained_in: Option<ECONOMICRESOURCE>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
current_location: Option<geo::SpatialThing>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
image: Option<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
lot: Option<dfc::ProductBatch>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
onhand_quantity: Option<om2::Measure>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
primary_accountable: Option<AGENT>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
stage: Option<PROCESSSPECIFICATION>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
state: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
tracking_identifier: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
unit_of_effort: Option<om2::Unit>,
}
impl<RESOURCESPECIFICATION, ECONOMICRESOURCE, AGENT, PROCESSSPECIFICATION> EconomicResource<RESOURCESPECIFICATION, ECONOMICRESOURCE, AGENT, PROCESSSPECIFICATION> {
#[allow(dead_code)]
pub fn builder() -> EconomicResourceBuilder<RESOURCESPECIFICATION, ECONOMICRESOURCE, AGENT, PROCESSSPECIFICATION> {
EconomicResourceBuilder {
accounting_quantity: None,
classified_as: None,
conforms_to: None,
contained_in: None,
current_location: None,
image: None,
lot: None,
name: None,
note: None,
onhand_quantity: None,
primary_accountable: None,
stage: None,
state: None,
tracking_identifier: None,
unit_of_effort: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> EconomicResourceBuilder<RESOURCESPECIFICATION, ECONOMICRESOURCE, AGENT, PROCESSSPECIFICATION> {
let EconomicResource { accounting_quantity, classified_as, conforms_to, contained_in, current_location, image, lot, name, note, onhand_quantity, primary_accountable, stage, state, tracking_identifier, unit_of_effort } = self;
let mut builder = Self::builder();
builder = match accounting_quantity { Some(x) => builder.accounting_quantity(x), None => builder };
builder = builder.classified_as(classified_as);
builder = builder.conforms_to(conforms_to);
builder = match contained_in { Some(x) => builder.contained_in(x), None => builder };
builder = match current_location { Some(x) => builder.current_location(x), None => builder };
builder = match image { Some(x) => builder.image(x), None => builder };
builder = match lot { Some(x) => builder.lot(x), None => builder };
builder = match name { Some(x) => builder.name(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match onhand_quantity { Some(x) => builder.onhand_quantity(x), None => builder };
builder = match primary_accountable { Some(x) => builder.primary_accountable(x), None => builder };
builder = match stage { Some(x) => builder.stage(x), None => builder };
builder = match state { Some(x) => builder.state(x), None => builder };
builder = match tracking_identifier { Some(x) => builder.tracking_identifier(x), None => builder };
builder = match unit_of_effort { Some(x) => builder.unit_of_effort(x), None => builder };
builder
}
}
}
pub use economic_resource::EconomicResource;
mod fulfillment {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Fulfillment<ECONOMICEVENT, COMMITMENT> {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
effort_quantity: Option<om2::Measure>,
fulfilled_by: ECONOMICEVENT,
fulfills: COMMITMENT,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_quantity: Option<om2::Measure>,
}
impl<ECONOMICEVENT, COMMITMENT> Fulfillment<ECONOMICEVENT, COMMITMENT> {
#[allow(dead_code)]
pub fn builder() -> FulfillmentBuilder<ECONOMICEVENT, COMMITMENT> {
FulfillmentBuilder {
effort_quantity: None,
fulfilled_by: None,
fulfills: None,
note: None,
resource_quantity: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> FulfillmentBuilder<ECONOMICEVENT, COMMITMENT> {
let Fulfillment { effort_quantity, fulfilled_by, fulfills, note, resource_quantity } = self;
let mut builder = Self::builder();
builder = match effort_quantity { Some(x) => builder.effort_quantity(x), None => builder };
builder = builder.fulfilled_by(fulfilled_by);
builder = builder.fulfills(fulfills);
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match resource_quantity { Some(x) => builder.resource_quantity(x), None => builder };
builder
}
}
}
pub use fulfillment::Fulfillment;
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub enum InputOutput {
#[serde(rename = "input")]
Input,
#[serde(rename = "output")]
Output,
}
mod intent {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Intent<PROCESS, AGENT, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
action: Action,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
agreed_in: Option<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
at_location: Option<geo::SpatialThing>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
available_quantity: Option<om2::Measure>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
due: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
effort_quantity: Option<om2::Measure>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
finished: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_beginning: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_end: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_point_in_time: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
image: Option<Url>,
#[builder(default)]
in_scope_of: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
input_of: Option<PROCESS>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
output_of: Option<PROCESS>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
provider: Option<AGENT>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
receiver: Option<AGENT>,
#[builder(default)]
resource_classified_as: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_conforms_to: Option<RESOURCESPECIFICATION>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_inventoried_as: Option<ECONOMICRESOURCE>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_quantity: Option<om2::Measure>,
}
impl<PROCESS, AGENT, RESOURCESPECIFICATION, ECONOMICRESOURCE> Intent<PROCESS, AGENT, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
#[allow(dead_code)]
pub fn builder() -> IntentBuilder<PROCESS, AGENT, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
IntentBuilder {
action: None,
agreed_in: None,
at_location: None,
available_quantity: None,
due: None,
effort_quantity: None,
finished: None,
has_beginning: None,
has_end: None,
has_point_in_time: None,
image: None,
in_scope_of: None,
input_of: None,
name: None,
note: None,
output_of: None,
provider: None,
receiver: None,
resource_classified_as: None,
resource_conforms_to: None,
resource_inventoried_as: None,
resource_quantity: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> IntentBuilder<PROCESS, AGENT, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
let Intent { action, agreed_in, at_location, available_quantity, due, effort_quantity, finished, has_beginning, has_end, has_point_in_time, image, in_scope_of, input_of, name, note, output_of, provider, receiver, resource_classified_as, resource_conforms_to, resource_inventoried_as, resource_quantity } = self;
let mut builder = Self::builder();
builder = builder.action(action);
builder = match agreed_in { Some(x) => builder.agreed_in(x), None => builder };
builder = match at_location { Some(x) => builder.at_location(x), None => builder };
builder = match available_quantity { Some(x) => builder.available_quantity(x), None => builder };
builder = match due { Some(x) => builder.due(x), None => builder };
builder = match effort_quantity { Some(x) => builder.effort_quantity(x), None => builder };
builder = match finished { Some(x) => builder.finished(x), None => builder };
builder = match has_beginning { Some(x) => builder.has_beginning(x), None => builder };
builder = match has_end { Some(x) => builder.has_end(x), None => builder };
builder = match has_point_in_time { Some(x) => builder.has_point_in_time(x), None => builder };
builder = match image { Some(x) => builder.image(x), None => builder };
builder = builder.in_scope_of(in_scope_of);
builder = match input_of { Some(x) => builder.input_of(x), None => builder };
builder = match name { Some(x) => builder.name(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match output_of { Some(x) => builder.output_of(x), None => builder };
builder = match provider { Some(x) => builder.provider(x), None => builder };
builder = match receiver { Some(x) => builder.receiver(x), None => builder };
builder = builder.resource_classified_as(resource_classified_as);
builder = match resource_conforms_to { Some(x) => builder.resource_conforms_to(x), None => builder };
builder = match resource_inventoried_as { Some(x) => builder.resource_inventoried_as(x), None => builder };
builder = match resource_quantity { Some(x) => builder.resource_quantity(x), None => builder };
builder
}
}
}
pub use intent::Intent;
mod plan {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Plan<SCENARIO> {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
created: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
due: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
refinement_of: Option<SCENARIO>,
}
impl<SCENARIO> Plan<SCENARIO> {
#[allow(dead_code)]
pub fn builder() -> PlanBuilder<SCENARIO> {
PlanBuilder {
created: None,
due: None,
name: None,
note: None,
refinement_of: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> PlanBuilder<SCENARIO> {
let Plan { created, due, name, note, refinement_of } = self;
let mut builder = Self::builder();
builder = match created { Some(x) => builder.created(x), None => builder };
builder = match due { Some(x) => builder.due(x), None => builder };
builder = match name { Some(x) => builder.name(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match refinement_of { Some(x) => builder.refinement_of(x), None => builder };
builder
}
}
}
pub use plan::Plan;
mod process {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Process<PROCESSSPECIFICATION, SCENARIO, PLAN> {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
based_on: Option<PROCESSSPECIFICATION>,
#[builder(default)]
classified_as: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
finished: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_beginning: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_end: Option<DateTime<Utc>>,
#[builder(default)]
in_scope_of: Vec<Url>,
name: String,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
nested_in: Option<SCENARIO>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
planned_within: Option<PLAN>,
}
impl<PROCESSSPECIFICATION, SCENARIO, PLAN> Process<PROCESSSPECIFICATION, SCENARIO, PLAN> {
#[allow(dead_code)]
pub fn builder() -> ProcessBuilder<PROCESSSPECIFICATION, SCENARIO, PLAN> {
ProcessBuilder {
based_on: None,
classified_as: None,
finished: None,
has_beginning: None,
has_end: None,
in_scope_of: None,
name: None,
nested_in: None,
note: None,
planned_within: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> ProcessBuilder<PROCESSSPECIFICATION, SCENARIO, PLAN> {
let Process { based_on, classified_as, finished, has_beginning, has_end, in_scope_of, name, nested_in, note, planned_within } = self;
let mut builder = Self::builder();
builder = match based_on { Some(x) => builder.based_on(x), None => builder };
builder = builder.classified_as(classified_as);
builder = match finished { Some(x) => builder.finished(x), None => builder };
builder = match has_beginning { Some(x) => builder.has_beginning(x), None => builder };
builder = match has_end { Some(x) => builder.has_end(x), None => builder };
builder = builder.in_scope_of(in_scope_of);
builder = builder.name(name);
builder = match nested_in { Some(x) => builder.nested_in(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match planned_within { Some(x) => builder.planned_within(x), None => builder };
builder
}
}
}
pub use process::Process;
mod process_specification {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct ProcessSpecification {
name: String,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
}
impl ProcessSpecification {
#[allow(dead_code)]
pub fn builder() -> ProcessSpecificationBuilder {
ProcessSpecificationBuilder {
name: None,
note: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> ProcessSpecificationBuilder {
let ProcessSpecification { name, note } = self;
let mut builder = Self::builder();
builder = builder.name(name);
builder = match note { Some(x) => builder.note(x), None => builder };
builder
}
}
}
pub use process_specification::ProcessSpecification;
mod proposal {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Proposal {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
created: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
eligible_location: Option<geo::SpatialThing>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_beginning: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_end: Option<DateTime<Utc>>,
#[builder(default)]
in_scope_of: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
unit_based: Option<bool>,
}
impl Proposal {
#[allow(dead_code)]
pub fn builder() -> ProposalBuilder {
ProposalBuilder {
created: None,
eligible_location: None,
has_beginning: None,
has_end: None,
in_scope_of: None,
name: None,
note: None,
unit_based: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> ProposalBuilder {
let Proposal { created, eligible_location, has_beginning, has_end, in_scope_of, name, note, unit_based } = self;
let mut builder = Self::builder();
builder = match created { Some(x) => builder.created(x), None => builder };
builder = match eligible_location { Some(x) => builder.eligible_location(x), None => builder };
builder = match has_beginning { Some(x) => builder.has_beginning(x), None => builder };
builder = match has_end { Some(x) => builder.has_end(x), None => builder };
builder = builder.in_scope_of(in_scope_of);
builder = match name { Some(x) => builder.name(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match unit_based { Some(x) => builder.unit_based(x), None => builder };
builder
}
}
}
pub use proposal::Proposal;
mod proposed_intent {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct ProposedIntent<PROPOSAL, INTENT> {
published_in: PROPOSAL,
publishes: INTENT,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
reciprocal: Option<bool>,
}
impl<PROPOSAL, INTENT> ProposedIntent<PROPOSAL, INTENT> {
#[allow(dead_code)]
pub fn builder() -> ProposedIntentBuilder<PROPOSAL, INTENT> {
ProposedIntentBuilder {
published_in: None,
publishes: None,
reciprocal: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> ProposedIntentBuilder<PROPOSAL, INTENT> {
let ProposedIntent { published_in, publishes, reciprocal } = self;
let mut builder = Self::builder();
builder = builder.published_in(published_in);
builder = builder.publishes(publishes);
builder = match reciprocal { Some(x) => builder.reciprocal(x), None => builder };
builder
}
}
}
pub use proposed_intent::ProposedIntent;
mod proposed_to {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct ProposedTo<PROPOSAL, AGENT> {
proposed: PROPOSAL,
proposed_to: AGENT,
}
impl<PROPOSAL, AGENT> ProposedTo<PROPOSAL, AGENT> {
#[allow(dead_code)]
pub fn builder() -> ProposedToBuilder<PROPOSAL, AGENT> {
ProposedToBuilder {
proposed: None,
proposed_to: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> ProposedToBuilder<PROPOSAL, AGENT> {
let ProposedTo { proposed, proposed_to } = self;
let mut builder = Self::builder();
builder = builder.proposed(proposed);
builder = builder.proposed_to(proposed_to);
builder
}
}
}
pub use proposed_to::ProposedTo;
mod recipe_flow {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct RecipeFlow<RECIPERESOURCE, RECIPEPROCESS> {
action: Action,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
effort_quantity: Option<om2::Measure>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
recipe_flow_resource: Option<RECIPERESOURCE>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
recipe_input_of: Option<RECIPEPROCESS>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
recipe_output_of: Option<RECIPEPROCESS>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_quantity: Option<om2::Measure>,
}
impl<RECIPERESOURCE, RECIPEPROCESS> RecipeFlow<RECIPERESOURCE, RECIPEPROCESS> {
#[allow(dead_code)]
pub fn builder() -> RecipeFlowBuilder<RECIPERESOURCE, RECIPEPROCESS> {
RecipeFlowBuilder {
action: None,
effort_quantity: None,
note: None,
recipe_flow_resource: None,
recipe_input_of: None,
recipe_output_of: None,
resource_quantity: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> RecipeFlowBuilder<RECIPERESOURCE, RECIPEPROCESS> {
let RecipeFlow { action, effort_quantity, note, recipe_flow_resource, recipe_input_of, recipe_output_of, resource_quantity } = self;
let mut builder = Self::builder();
builder = builder.action(action);
builder = match effort_quantity { Some(x) => builder.effort_quantity(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match recipe_flow_resource { Some(x) => builder.recipe_flow_resource(x), None => builder };
builder = match recipe_input_of { Some(x) => builder.recipe_input_of(x), None => builder };
builder = match recipe_output_of { Some(x) => builder.recipe_output_of(x), None => builder };
builder = match resource_quantity { Some(x) => builder.resource_quantity(x), None => builder };
builder
}
}
}
pub use recipe_flow::RecipeFlow;
mod recipe_process {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct RecipeProcess<PROCESSSPECIFICATION> {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_duration: Option<Duration>,
name: String,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[builder(default)]
process_classified_as: Vec<Url>,
process_conforms_to: PROCESSSPECIFICATION,
}
impl<PROCESSSPECIFICATION> RecipeProcess<PROCESSSPECIFICATION> {
#[allow(dead_code)]
pub fn builder() -> RecipeProcessBuilder<PROCESSSPECIFICATION> {
RecipeProcessBuilder {
has_duration: None,
name: None,
note: None,
process_classified_as: None,
process_conforms_to: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> RecipeProcessBuilder<PROCESSSPECIFICATION> {
let RecipeProcess { has_duration, name, note, process_classified_as, process_conforms_to } = self;
let mut builder = Self::builder();
builder = match has_duration { Some(x) => builder.has_duration(x), None => builder };
builder = builder.name(name);
builder = match note { Some(x) => builder.note(x), None => builder };
builder = builder.process_classified_as(process_classified_as);
builder = builder.process_conforms_to(process_conforms_to);
builder
}
}
}
pub use recipe_process::RecipeProcess;
mod recipe_resource {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct RecipeResource<RESOURCESPECIFICATION> {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
image: Option<Url>,
name: String,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[builder(default)]
resource_classified_as: Vec<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_conforms_to: Option<RESOURCESPECIFICATION>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
substitutable: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
unit_of_effort: Option<om2::Unit>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
unit_of_resource: Option<om2::Unit>,
}
impl<RESOURCESPECIFICATION> RecipeResource<RESOURCESPECIFICATION> {
#[allow(dead_code)]
pub fn builder() -> RecipeResourceBuilder<RESOURCESPECIFICATION> {
RecipeResourceBuilder {
image: None,
name: None,
note: None,
resource_classified_as: None,
resource_conforms_to: None,
substitutable: None,
unit_of_effort: None,
unit_of_resource: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> RecipeResourceBuilder<RESOURCESPECIFICATION> {
let RecipeResource { image, name, note, resource_classified_as, resource_conforms_to, substitutable, unit_of_effort, unit_of_resource } = self;
let mut builder = Self::builder();
builder = match image { Some(x) => builder.image(x), None => builder };
builder = builder.name(name);
builder = match note { Some(x) => builder.note(x), None => builder };
builder = builder.resource_classified_as(resource_classified_as);
builder = match resource_conforms_to { Some(x) => builder.resource_conforms_to(x), None => builder };
builder = match substitutable { Some(x) => builder.substitutable(x), None => builder };
builder = match unit_of_effort { Some(x) => builder.unit_of_effort(x), None => builder };
builder = match unit_of_resource { Some(x) => builder.unit_of_resource(x), None => builder };
builder
}
}
}
pub use recipe_resource::RecipeResource;
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub enum ResourceEffect {
#[serde(rename = "decrement")]
Decrement,
#[serde(rename = "decrement-increment")]
DecrementIncrement,
#[serde(rename = "increment")]
Increment,
#[serde(rename = "no-effect")]
NoEffect,
}
mod resource_specification {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct ResourceSpecification {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
image: Option<Url>,
name: String,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[builder(default)]
resource_classified_as: Vec<Url>,
}
impl ResourceSpecification {
#[allow(dead_code)]
pub fn builder() -> ResourceSpecificationBuilder {
ResourceSpecificationBuilder {
image: None,
name: None,
note: None,
resource_classified_as: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> ResourceSpecificationBuilder {
let ResourceSpecification { image, name, note, resource_classified_as } = self;
let mut builder = Self::builder();
builder = match image { Some(x) => builder.image(x), None => builder };
builder = builder.name(name);
builder = match note { Some(x) => builder.note(x), None => builder };
builder = builder.resource_classified_as(resource_classified_as);
builder
}
}
}
pub use resource_specification::ResourceSpecification;
mod satisfaction {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Satisfaction<COMMITMENT, ECONOMICEVENT, INTENT> {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
effort_quantity: Option<om2::Measure>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_quantity: Option<om2::Measure>,
satisfied_by: CommitmentEconomicEventUnion<COMMITMENT, ECONOMICEVENT>,
satisfies: INTENT,
}
impl<COMMITMENT, ECONOMICEVENT, INTENT> Satisfaction<COMMITMENT, ECONOMICEVENT, INTENT> {
#[allow(dead_code)]
pub fn builder() -> SatisfactionBuilder<COMMITMENT, ECONOMICEVENT, INTENT> {
SatisfactionBuilder {
effort_quantity: None,
note: None,
resource_quantity: None,
satisfied_by: None,
satisfies: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> SatisfactionBuilder<COMMITMENT, ECONOMICEVENT, INTENT> {
let Satisfaction { effort_quantity, note, resource_quantity, satisfied_by, satisfies } = self;
let mut builder = Self::builder();
builder = match effort_quantity { Some(x) => builder.effort_quantity(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match resource_quantity { Some(x) => builder.resource_quantity(x), None => builder };
builder = builder.satisfied_by(satisfied_by);
builder = builder.satisfies(satisfies);
builder
}
}
}
pub use satisfaction::Satisfaction;
mod scenario {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Scenario<SCENARIODEFINITION, SCENARIO> {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
defined_as: Option<SCENARIODEFINITION>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_beginning: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_end: Option<DateTime<Utc>>,
#[builder(default)]
in_scope_of: Vec<Url>,
name: String,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
refinement_of: Option<SCENARIO>,
}
impl<SCENARIODEFINITION, SCENARIO> Scenario<SCENARIODEFINITION, SCENARIO> {
#[allow(dead_code)]
pub fn builder() -> ScenarioBuilder<SCENARIODEFINITION, SCENARIO> {
ScenarioBuilder {
defined_as: None,
has_beginning: None,
has_end: None,
in_scope_of: None,
name: None,
note: None,
refinement_of: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> ScenarioBuilder<SCENARIODEFINITION, SCENARIO> {
let Scenario { defined_as, has_beginning, has_end, in_scope_of, name, note, refinement_of } = self;
let mut builder = Self::builder();
builder = match defined_as { Some(x) => builder.defined_as(x), None => builder };
builder = match has_beginning { Some(x) => builder.has_beginning(x), None => builder };
builder = match has_end { Some(x) => builder.has_end(x), None => builder };
builder = builder.in_scope_of(in_scope_of);
builder = builder.name(name);
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match refinement_of { Some(x) => builder.refinement_of(x), None => builder };
builder
}
}
}
pub use scenario::Scenario;
mod scenario_definition {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct ScenarioDefinition {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
has_duration: Option<Duration>,
name: String,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
}
impl ScenarioDefinition {
#[allow(dead_code)]
pub fn builder() -> ScenarioDefinitionBuilder {
ScenarioDefinitionBuilder {
has_duration: None,
name: None,
note: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> ScenarioDefinitionBuilder {
let ScenarioDefinition { has_duration, name, note } = self;
let mut builder = Self::builder();
builder = match has_duration { Some(x) => builder.has_duration(x), None => builder };
builder = builder.name(name);
builder = match note { Some(x) => builder.note(x), None => builder };
builder
}
}
}
pub use scenario_definition::ScenarioDefinition;
mod settlement {
use super::*;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Builder, Getters)]
#[derive(Setters)]
#[derive(MutGetters)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub", set = "pub", get_mut = "pub")]
pub struct Settlement<ECONOMICEVENT, CLAIM> {
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
effort_quantity: Option<om2::Measure>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[builder(setter(strip_option), default)]
resource_quantity: Option<om2::Measure>,
settled_by: ECONOMICEVENT,
settles: CLAIM,
}
impl<ECONOMICEVENT, CLAIM> Settlement<ECONOMICEVENT, CLAIM> {
#[allow(dead_code)]
pub fn builder() -> SettlementBuilder<ECONOMICEVENT, CLAIM> {
SettlementBuilder {
effort_quantity: None,
note: None,
resource_quantity: None,
settled_by: None,
settles: None,
}
}
#[allow(dead_code)]
pub fn into_builder(self) -> SettlementBuilder<ECONOMICEVENT, CLAIM> {
let Settlement { effort_quantity, note, resource_quantity, settled_by, settles } = self;
let mut builder = Self::builder();
builder = match effort_quantity { Some(x) => builder.effort_quantity(x), None => builder };
builder = match note { Some(x) => builder.note(x), None => builder };
builder = match resource_quantity { Some(x) => builder.resource_quantity(x), None => builder };
builder = builder.settled_by(settled_by);
builder = builder.settles(settles);
builder
}
}
}
pub use settlement::Settlement;
pub mod builders {
pub use super::agent::AgentBuilder;
pub use super::agent_relationship::AgentRelationshipBuilder;
pub use super::agent_relationship_role::AgentRelationshipRoleBuilder;
pub use super::agreement::AgreementBuilder;
pub use super::appreciation::AppreciationBuilder;
pub use super::claim::ClaimBuilder;
pub use super::commitment::CommitmentBuilder;
pub use super::economic_event::EconomicEventBuilder;
pub use super::economic_resource::EconomicResourceBuilder;
pub use super::fulfillment::FulfillmentBuilder;
pub use super::intent::IntentBuilder;
pub use super::plan::PlanBuilder;
pub use super::process::ProcessBuilder;
pub use super::process_specification::ProcessSpecificationBuilder;
pub use super::proposal::ProposalBuilder;
pub use super::proposed_intent::ProposedIntentBuilder;
pub use super::proposed_to::ProposedToBuilder;
pub use super::recipe_flow::RecipeFlowBuilder;
pub use super::recipe_process::RecipeProcessBuilder;
pub use super::recipe_resource::RecipeResourceBuilder;
pub use super::resource_specification::ResourceSpecificationBuilder;
pub use super::satisfaction::SatisfactionBuilder;
pub use super::scenario::ScenarioBuilder;
pub use super::scenario_definition::ScenarioDefinitionBuilder;
pub use super::settlement::SettlementBuilder;
}
}