use std::time::Duration;
use chrono::prelude::*;
use derive_builder::Builder;
use getset::Getters;
use getset::Setters;
use getset::MutGetters;
#[cfg(feature = "with_serde")]use serde_derive::{Serialize, Deserialize};
use url::Url;

/// Supportive module holding the ProductBatch struct used in some of the VF structs
pub mod dfc {
    use super::*;

    mod product_batch {
        use super::*;

        /// A lot or batch, defining a resource produced at the same time in the same way. From DataFoodConsortium vocabulary https://datafoodconsortium.gitbook.io/dfc-standard-documentation/.
        ///
        /// ID: <http://www.virtual-assembly.org/DataFoodConsortium/BusinessOntology#ProductBatch>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct ProductBatch {
            batch_number: String,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            expiry_date: Option<DateTime<Utc>>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            production_date: Option<DateTime<Utc>>,
        }

        impl ProductBatch {
            /// Create an empty builder object for ProductBatch
            #[allow(dead_code)]
            pub fn builder() -> ProductBatchBuilder {
                // We avoid using ProductBatchBuilder::default() here because it requires all our generics to derive Default =[
                ProductBatchBuilder {
                    batch_number: None,
                    expiry_date: None,
                    production_date: None,
                }
            }

            /// Turns ProductBatch into ProductBatchBuilder
            #[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;

    /// Holds the supporting builder structs for our dfc types. Create a builder via `SomeType::builder()`.
    pub mod builders {
        pub use super::product_batch::ProductBatchBuilder;
    }
}

/// Supportive module containing SpatialThing used in various VF structs
pub mod geo {
    use super::*;

    mod spatial_thing {
        use super::*;

        /// A mappable location.
        ///
        /// ID: <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct SpatialThing {
            /// The WGS84 altitude of a SpatialThing (decimal meters above the local reference ellipsoid).
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            alt: Option<f64>,
            /// The WGS84 latitude of a SpatialThing (decimal degrees).
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            lat: Option<f64>,
            /// The WGS84 longitude of a SpatialThing (decimal degrees).
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            long: Option<f64>,
            /// A textual address that can be mapped using mapping software.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            mappable_address: Option<String>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            name: Option<String>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
        }

        impl SpatialThing {
            /// Create an empty builder object for SpatialThing
            #[allow(dead_code)]
            pub fn builder() -> SpatialThingBuilder {
                // We avoid using SpatialThingBuilder::default() here because it requires all our generics to derive Default =[
                SpatialThingBuilder {
                    alt: None,
                    lat: None,
                    long: None,
                    mappable_address: None,
                    name: None,
                    note: None,
                }
            }

            /// Turns SpatialThing into SpatialThingBuilder
            #[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;

    /// Holds the supporting builder structs for our geo types. Create a builder via `SomeType::builder()`.
    pub mod builders {
        pub use super::spatial_thing::SpatialThingBuilder;
    }
}

/// The main ValueFlows module which holds the VF classes.
pub mod vf {
    use super::*;

    /// An enum that allows a type union for (Commitment, EconomicEvent, Intent)
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum CommitmentEconomicEventIntentUnion<COMMITMENT, ECONOMICEVENT, INTENT> {
        Commitment(COMMITMENT),
        EconomicEvent(ECONOMICEVENT),
        Intent(INTENT),
    }

    /// An enum that allows a type union for (Commitment, Intent, Process)
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum CommitmentIntentProcessUnion<COMMITMENT, INTENT, PROCESS> {
        Commitment(COMMITMENT),
        Intent(INTENT),
        Process(PROCESS),
    }

    /// The action has this effect on an inventoried resource primary accountable agent.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#AccountableEffect>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum AccountableEffect {
        /// The effect applies for a new resource created by the event.
        #[cfg_attr(feature = "with_serde", serde(rename = "remove"))]
        New,
        /// The effect is to update the to resource in the specified property.
        #[cfg_attr(feature = "with_serde", serde(rename = "update"))]
        UpdateTo,
    }

    /// The action has this effect on an inventoried resource accounting quantity.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#AccountingEffect>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum AccountingEffect {
        /// The effect is to subtract from the inventoried resource accounting or onhand quantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "decrement"))]
        Decrement,
        /// The effect is to subtract from the 'from' inventoried resource, and add to the 'to' inventoried resource, accounting or onhand quantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "decrement-increment"))]
        DecrementIncrement,
        /// The effect is to add to the inventoried resource accounting or onhand quantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "increment"))]
        Increment,
        /// The effect is to add to the to (receiver) inventoried resource accounting or onhand quantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "increment-to"))]
        IncrementTo,
    }

    /// An action verb defining the kind of flow and its behavior.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#Action>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum Action {
        /// In processes like repair or modification or testing, the same resource will appear in the output.
        #[cfg_attr(feature = "with_serde", serde(rename = "accept"))]
        Accept,
        /// For example a design file, neither used nor consumed, the file remains available at all times.
        #[cfg_attr(feature = "with_serde", serde(rename = "cite"))]
        Cite,
        /// A resource is combined with other resources into a container resource.
        #[cfg_attr(feature = "with_serde", serde(rename = "combine"))]
        Combine,
        /// For example an ingredient or component composed into the output, after the process the ingredient is gone.
        #[cfg_attr(feature = "with_serde", serde(rename = "consume"))]
        Consume,
        /// Create a new version of the resource, without any change to the original.
        #[cfg_attr(feature = "with_serde", serde(rename = "copy"))]
        Copy,
        /// New service produced and delivered (a service implies that an agent actively receives the service).
        #[cfg_attr(feature = "with_serde", serde(rename = "deliver-service"))]
        DeliverService,
        /// Transported resource or person leaves the process; the same resource or person appeared in the input.
        #[cfg_attr(feature = "with_serde", serde(rename = "dropoff"))]
        Dropoff,
        /// Adjusts a quantity down based on a beginning balance or inventory count.
        #[cfg_attr(feature = "with_serde", serde(rename = "lower"))]
        Lower,
        /// In processes like repair or modification, the same resource will appear in the input.
        #[cfg_attr(feature = "with_serde", serde(rename = "modify"))]
        Modify,
        /// Change location and possibly identifier, if location is part of the identification, of a resource with no change of agent rights or possession.
        #[cfg_attr(feature = "with_serde", serde(rename = "move"))]
        Move,
        /// Transported resource or person enters the process; the same resource will appear in the output.
        #[cfg_attr(feature = "with_serde", serde(rename = "pickup"))]
        Pickup,
        /// New resource was created in that process or an existing stock resource was added to.
        #[cfg_attr(feature = "with_serde", serde(rename = "produce"))]
        Produce,
        /// Adjusts a quantity up based on a beginning balance or inventory count.
        #[cfg_attr(feature = "with_serde", serde(rename = "raise"))]
        Raise,
        /// A resource is removed from a container resource.
        #[cfg_attr(feature = "with_serde", serde(rename = "unpack"))]
        Separate,
        /// Give full rights and responsibilities plus physical custody.
        #[cfg_attr(feature = "with_serde", serde(rename = "transfer"))]
        Transfer,
        /// Give full (in the human realm) rights and responsibilities to another agent, without transferring physical custody.
        #[cfg_attr(feature = "with_serde", serde(rename = "transfer-all-rights"))]
        TransferAllRights,
        /// Give physical custody and control of a resource, without full accounting or ownership rights.
        #[cfg_attr(feature = "with_serde", serde(rename = "transfer-custody"))]
        TransferCustody,
        /// For example a tool used in process; after the process, the tool still exists.
        #[cfg_attr(feature = "with_serde", serde(rename = "use"))]
        Use,
        /// Labor power applied to a process.
        #[cfg_attr(feature = "with_serde", serde(rename = "work"))]
        Work,
    }

    impl Action {
        #[allow(dead_code)]
        pub fn accountable_effect(&self) -> Option<AccountableEffect> {
            match self {
                Self::Copy => Some(AccountableEffect::New),
                Self::Lower => Some(AccountableEffect::New),
                Self::Produce => Some(AccountableEffect::New),
                Self::Raise => Some(AccountableEffect::New),
                Self::Transfer => Some(AccountableEffect::UpdateTo),
                Self::TransferAllRights => Some(AccountableEffect::UpdateTo),
                _ => None,
            }
        }

        #[allow(dead_code)]
        pub fn accounting_effect(&self) -> Option<AccountingEffect> {
            match self {
                Self::Consume => Some(AccountingEffect::Decrement),
                Self::Copy => Some(AccountingEffect::IncrementTo),
                Self::Lower => Some(AccountingEffect::Decrement),
                Self::Move => Some(AccountingEffect::DecrementIncrement),
                Self::Produce => Some(AccountingEffect::Increment),
                Self::Raise => Some(AccountingEffect::Increment),
                Self::Transfer => Some(AccountingEffect::DecrementIncrement),
                Self::TransferAllRights => Some(AccountingEffect::DecrementIncrement),
                _ => None,
            }
        }

        #[allow(dead_code)]
        pub fn can_create_resource(&self) -> Option<CreateResource> {
            match self {
                _ => None,
            }
        }

        #[allow(dead_code)]
        pub fn contained_effect(&self) -> Option<ContainedEffect> {
            match self {
                Self::Combine => Some(ContainedEffect::Update),
                Self::Separate => Some(ContainedEffect::Remove),
                _ => None,
            }
        }

        #[allow(dead_code)]
        pub fn event_quantity(&self) -> EventQuantity {
            match self {
                Self::Accept => EventQuantity::Resource,
                Self::Cite => EventQuantity::Resource,
                Self::Combine => EventQuantity::Resource,
                Self::Consume => EventQuantity::Resource,
                Self::Copy => EventQuantity::Resource,
                Self::DeliverService => EventQuantity::Resource,
                Self::Dropoff => EventQuantity::Resource,
                Self::Lower => EventQuantity::Resource,
                Self::Modify => EventQuantity::Resource,
                Self::Move => EventQuantity::Resource,
                Self::Pickup => EventQuantity::Resource,
                Self::Produce => EventQuantity::Resource,
                Self::Raise => EventQuantity::Resource,
                Self::Separate => EventQuantity::Resource,
                Self::Transfer => EventQuantity::Resource,
                Self::TransferAllRights => EventQuantity::Resource,
                Self::TransferCustody => EventQuantity::Resource,
                Self::Use => EventQuantity::Both,
                Self::Work => EventQuantity::Effort,
            }
        }

        #[allow(dead_code)]
        pub fn input_output(&self) -> Option<InputOutput> {
            match self {
                Self::Accept => Some(InputOutput::Input),
                Self::Cite => Some(InputOutput::Input),
                Self::Combine => Some(InputOutput::Input),
                Self::Consume => Some(InputOutput::Input),
                Self::DeliverService => Some(InputOutput::OutputInput),
                Self::Dropoff => Some(InputOutput::Output),
                Self::Modify => Some(InputOutput::Output),
                Self::Pickup => Some(InputOutput::Input),
                Self::Produce => Some(InputOutput::Output),
                Self::Separate => Some(InputOutput::Output),
                Self::Use => Some(InputOutput::Input),
                Self::Work => Some(InputOutput::Input),
                _ => None,
            }
        }

        #[allow(dead_code)]
        pub fn location_effect(&self) -> Option<LocationEffect> {
            match self {
                Self::Accept => Some(LocationEffect::Update),
                Self::Copy => Some(LocationEffect::New),
                Self::Dropoff => Some(LocationEffect::Update),
                Self::Modify => Some(LocationEffect::Update),
                Self::Move => Some(LocationEffect::UpdateTo),
                Self::Pickup => Some(LocationEffect::Update),
                Self::Produce => Some(LocationEffect::New),
                Self::Transfer => Some(LocationEffect::UpdateTo),
                Self::TransferCustody => Some(LocationEffect::UpdateTo),
                _ => None,
            }
        }

        #[allow(dead_code)]
        pub fn onhand_effect(&self) -> Option<OnhandEffect> {
            match self {
                Self::Accept => Some(OnhandEffect::Decrement),
                Self::Combine => Some(OnhandEffect::Decrement),
                Self::Consume => Some(OnhandEffect::Decrement),
                Self::Copy => Some(OnhandEffect::IncrementTo),
                Self::Lower => Some(OnhandEffect::Decrement),
                Self::Modify => Some(OnhandEffect::Increment),
                Self::Move => Some(OnhandEffect::DecrementIncrement),
                Self::Produce => Some(OnhandEffect::Increment),
                Self::Raise => Some(OnhandEffect::Increment),
                Self::Separate => Some(OnhandEffect::Increment),
                Self::Transfer => Some(OnhandEffect::DecrementIncrement),
                Self::TransferCustody => Some(OnhandEffect::DecrementIncrement),
                _ => 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 stage_effect(&self) -> Option<StageEffect> {
            match self {
                Self::Dropoff => Some(StageEffect::Update),
                Self::Modify => Some(StageEffect::Update),
                Self::Produce => Some(StageEffect::Update),
                Self::Separate => Some(StageEffect::Update),
                _ => None,
            }
        }

        #[allow(dead_code)]
        pub fn state_effect(&self) -> Option<StateEffect> {
            match self {
                Self::Accept => Some(StateEffect::Update),
                Self::Cite => Some(StateEffect::Update),
                Self::Combine => Some(StateEffect::Update),
                Self::Consume => Some(StateEffect::Update),
                Self::Copy => Some(StateEffect::UpdateTo),
                Self::Dropoff => Some(StateEffect::Update),
                Self::Lower => Some(StateEffect::Update),
                Self::Modify => Some(StateEffect::Update),
                Self::Move => Some(StateEffect::UpdateTo),
                Self::Pickup => Some(StateEffect::Update),
                Self::Produce => Some(StateEffect::Update),
                Self::Raise => Some(StateEffect::Update),
                Self::Separate => Some(StateEffect::Update),
                Self::Transfer => Some(StateEffect::UpdateTo),
                Self::TransferAllRights => Some(StateEffect::UpdateTo),
                Self::TransferCustody => Some(StateEffect::UpdateTo),
                Self::Use => Some(StateEffect::Update),
                _ => None,
            }
        }

    }

    mod agent {
        use super::*;

        /// An entity that can commit to and/or perform economic and/or ecological activity under its own power or authority.
        ///
        /// ID: <http://xmlns.com/foaf/0.1/Agent>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Agent {
            /// The uri to an image relevant to the entity, such as a logo, avatar, photo, diagram, etc.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            image: Option<Url>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            name: String,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// The main place an agent is located, often an address where activities occur and mail can be sent. This is usually a mappable geographic location.  It also could be a website address, as in the case of agents who have no physical location.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            primary_location: Option<geo::SpatialThing>,
        }

        impl Agent {
            /// Create an empty builder object for Agent
            #[allow(dead_code)]
            pub fn builder() -> AgentBuilder {
                // We avoid using AgentBuilder::default() here because it requires all our generics to derive Default =[
                AgentBuilder {
                    image: None,
                    name: None,
                    note: None,
                    primary_location: None,
                }
            }

            /// Turns Agent into AgentBuilder
            #[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::*;

        /// An ongoing voluntary association between 2 agents of any kind.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#AgentRelationship>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct AgentRelationship<AGENT, AGENTRELATIONSHIPROLE> {
            /// In the context of an agent, a grouping generally used for accounting, reporting.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            in_scope_of: Vec<AGENT>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// The object of a relationship between 2 agents.  For example, if Mary is a member of a group, then the group is the object.
            object: AGENT,
            /// The role of an economic relationship that exists between 2 agents, such as member, trading partner.
            relationship: AGENTRELATIONSHIPROLE,
            /// The subject of a relationship between 2 agents.  For example, if Mary is a member of a group, then Mary is the subject.
            subject: AGENT,
        }

        impl<AGENT, AGENTRELATIONSHIPROLE> AgentRelationship<AGENT, AGENTRELATIONSHIPROLE> {
            /// Create an empty builder object for AgentRelationship
            #[allow(dead_code)]
            pub fn builder() -> AgentRelationshipBuilder<AGENT, AGENTRELATIONSHIPROLE> {
                // We avoid using AgentRelationshipBuilder::default() here because it requires all our generics to derive Default =[
                AgentRelationshipBuilder {
                    in_scope_of: None,
                    note: None,
                    object: None,
                    relationship: None,
                    subject: None,
                }
            }

            /// Turns AgentRelationship into AgentRelationshipBuilder
            #[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::*;

        /// A relationship role defining the kind of association one agent can have with another.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#AgentRelationshipRole>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct AgentRelationshipRole {
            /// The human readable name of the role, inverse from the object to the subject. For example, 'has member'.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            inverse_role_label: Option<String>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// The generalized behavior of this agent relationship role.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            role_behavior: Option<RoleBehavior>,
            /// The human readable name of the role, inverse from the object to the subject. For example, 'is member of'.
            role_label: String,
        }

        impl AgentRelationshipRole {
            /// Create an empty builder object for AgentRelationshipRole
            #[allow(dead_code)]
            pub fn builder() -> AgentRelationshipRoleBuilder {
                // We avoid using AgentRelationshipRoleBuilder::default() here because it requires all our generics to derive Default =[
                AgentRelationshipRoleBuilder {
                    inverse_role_label: None,
                    note: None,
                    role_behavior: None,
                    role_label: None,
                }
            }

            /// Turns AgentRelationshipRole into AgentRelationshipRoleBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> AgentRelationshipRoleBuilder {
                let AgentRelationshipRole { inverse_role_label, note, role_behavior, 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 = match role_behavior { Some(x) => builder.role_behavior(x), None => builder };
                builder = builder.role_label(role_label);
                builder
            }
        }
    }
    pub use agent_relationship_role::AgentRelationshipRole;

    mod agreement {
        use super::*;

        /// Any type of agreement among economic agents.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Agreement>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Agreement<AGREEMENTBUNDLE, ECONOMICEVENT, COMMITMENT> {
            /// This agreement is bundled with other agreements.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            bundled_in: Option<AGREEMENTBUNDLE>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            created: Option<DateTime<Utc>>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            name: Option<String>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// All the non-reciprocal economic events (with or without commitments) that realize the agreement.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            realizes: Option<ECONOMICEVENT>,
            /// All the reciprocal economic events (with or without commitments) that realize the agreement.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            realizes_reciprocal: Option<ECONOMICEVENT>,
            /// All the primary commitments that constitute the agreement.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            stipulates: Option<COMMITMENT>,
            /// All the reciprocal commitments that constitute the agreement.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            stipulates_reciprocal: Option<COMMITMENT>,
        }

        impl<AGREEMENTBUNDLE, ECONOMICEVENT, COMMITMENT> Agreement<AGREEMENTBUNDLE, ECONOMICEVENT, COMMITMENT> {
            /// Create an empty builder object for Agreement
            #[allow(dead_code)]
            pub fn builder() -> AgreementBuilder<AGREEMENTBUNDLE, ECONOMICEVENT, COMMITMENT> {
                // We avoid using AgreementBuilder::default() here because it requires all our generics to derive Default =[
                AgreementBuilder {
                    bundled_in: None,
                    created: None,
                    name: None,
                    note: None,
                    realizes: None,
                    realizes_reciprocal: None,
                    stipulates: None,
                    stipulates_reciprocal: None,
                }
            }

            /// Turns Agreement into AgreementBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> AgreementBuilder<AGREEMENTBUNDLE, ECONOMICEVENT, COMMITMENT> {
                let Agreement { bundled_in, created, name, note, realizes, realizes_reciprocal, stipulates, stipulates_reciprocal } = self;
                let mut builder = Self::builder();
                builder = match bundled_in { Some(x) => builder.bundled_in(x), None => 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 = match realizes { Some(x) => builder.realizes(x), None => builder };
                builder = match realizes_reciprocal { Some(x) => builder.realizes_reciprocal(x), None => builder };
                builder = match stipulates { Some(x) => builder.stipulates(x), None => builder };
                builder = match stipulates_reciprocal { Some(x) => builder.stipulates_reciprocal(x), None => builder };
                builder
            }
        }
    }
    pub use agreement::Agreement;

    mod agreement_bundle {
        use super::*;

        /// A grouping of agreements to bundle detailed line item reciprocity.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#AgreementBundle>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct AgreementBundle<AGREEMENT> {
            /// All the agreements included in this agreement bundle.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            bundles: Option<AGREEMENT>,
        }

        impl<AGREEMENT> AgreementBundle<AGREEMENT> {
            /// Create an empty builder object for AgreementBundle
            #[allow(dead_code)]
            pub fn builder() -> AgreementBundleBuilder<AGREEMENT> {
                // We avoid using AgreementBundleBuilder::default() here because it requires all our generics to derive Default =[
                AgreementBundleBuilder {
                    bundles: None,
                }
            }

            /// Turns AgreementBundle into AgreementBundleBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> AgreementBundleBuilder<AGREEMENT> {
                let AgreementBundle { bundles } = self;
                let mut builder = Self::builder();
                builder = match bundles { Some(x) => builder.bundles(x), None => builder };
                builder
            }
        }
    }
    pub use agreement_bundle::AgreementBundle;

    mod appreciation {
        use super::*;

        /// A way to tie an economic event that is given in loose fulfilment for another economic event, without commitments or expectations. Supports the gift economy.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Appreciation>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Appreciation<ECONOMICEVENT> {
            /// The economic event being appreciated (gift economy).
            appreciation_of: ECONOMICEVENT,
            /// The economic event implemented in appreciation (gift economy).
            appreciation_with: ECONOMICEVENT,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
        }

        impl<ECONOMICEVENT> Appreciation<ECONOMICEVENT> {
            /// Create an empty builder object for Appreciation
            #[allow(dead_code)]
            pub fn builder() -> AppreciationBuilder<ECONOMICEVENT> {
                // We avoid using AppreciationBuilder::default() here because it requires all our generics to derive Default =[
                AppreciationBuilder {
                    appreciation_of: None,
                    appreciation_with: None,
                    note: None,
                }
            }

            /// Turns Appreciation into AppreciationBuilder
            #[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::*;

        /// A claim for a future economic event(s) in reciprocity for an economic event that already occurred. For example, a claim for payment for goods received.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Claim>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Claim<AGENT, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICEVENT> {
            /// Defines the kind of flow, such as consume, produce, work, transfer, etc.
            action: Action,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            created: Option<DateTime<Utc>>,
            /// The time something is expected to be complete.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            due: Option<DateTime<Utc>>,
            /// The amount and unit of the work or use or citation effort-based action. This is often a time duration, but also could be cycle counts or other measures of effort or usefulness.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            effort_quantity: Option<om2::Measure>,
            /// The commitment or intent or process is complete or not.  This is irrespective of if the original goal has been met, and indicates that no more will be done.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            finished: Option<bool>,
            /// In the context of an agent, a grouping generally used for accounting, reporting.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            in_scope_of: Vec<AGENT>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// The economic agent from whom the intended, committed, or actual economic event is initiated.
            provider: AGENT,
            /// The economic agent whom the intended, committed, or actual economic event is for.
            receiver: AGENT,
            /// References a concept in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            resource_classified_as: Vec<RESOURCECLASSIFIEDAS>,
            /// The primary resource specification or definition of an existing or potential economic resource. A resource will have only one, as this specifies exactly what the resource is.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_conforms_to: Option<RESOURCESPECIFICATION>,
            /// The amount and unit of the economic resource counted or inventoried.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_quantity: Option<om2::Measure>,
            /// References an economic event that implied the claim or event, often based on a prior agreement.
            triggered_by: ECONOMICEVENT,
        }

        impl<AGENT, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICEVENT> Claim<AGENT, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICEVENT> {
            /// Create an empty builder object for Claim
            #[allow(dead_code)]
            pub fn builder() -> ClaimBuilder<AGENT, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICEVENT> {
                // We avoid using ClaimBuilder::default() here because it requires all our generics to derive Default =[
                ClaimBuilder {
                    action: 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,
                }
            }

            /// Turns Claim into ClaimBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> ClaimBuilder<AGENT, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICEVENT> {
                let Claim { action, 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 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::*;

        /// A planned economic flow that has been promised by an agent to another agent.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Commitment>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Commitment<AGREEMENT, AGENT, PLAN, PROCESS, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, INTENT, PROCESSSPECIFICATION> {
            /// Defines the kind of flow, such as consume, produce, work, transfer, etc.
            action: Action,
            /// The place where an intent, commitment, or economic event occurs.  Usually mappable.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            at_location: Option<geo::SpatialThing>,
            /// This commitment is a primary part of the agreement.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            clause_of: Option<AGREEMENT>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            created: Option<DateTime<Utc>>,
            /// The time something is expected to be complete.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            due: Option<DateTime<Utc>>,
            /// The amount and unit of the work or use or citation effort-based action. This is often a time duration, but also could be cycle counts or other measures of effort or usefulness.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            effort_quantity: Option<om2::Measure>,
            /// The commitment or intent or process is complete or not.  This is irrespective of if the original goal has been met, and indicates that no more will be done.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            finished: Option<bool>,
            /// The planned or actual beginning of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_beginning: Option<DateTime<Utc>>,
            /// The planned or actual end of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_end: Option<DateTime<Utc>>,
            /// The planned or actual time of a flow; can be used instead of hasBeginning and hasEnd, if so, hasBeginning and hasEnd should be able to be returned with this value.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_point_in_time: Option<DateTime<Utc>>,
            /// In the context of an agent, a grouping generally used for accounting, reporting.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            in_scope_of: Vec<AGENT>,
            /// Represents a desired deliverable expected from this plan.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            independent_demand_of: Option<PLAN>,
            /// Relates an input flow to its process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            input_of: Option<PROCESS>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// Relates an output flow to its process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            output_of: Option<PROCESS>,
            /// The non-process commitment/intent or process with its inputs and outputs is part of the plan.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            planned_within: Option<PLAN>,
            /// The economic agent from whom the intended, committed, or actual economic event is initiated.
            provider: AGENT,
            /// The economic agent whom the intended, committed, or actual economic event is for.
            receiver: AGENT,
            /// This commitment is a reciprocal part of the agreement.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            reciprocal_clause_of: Option<AGREEMENT>,
            /// References a concept in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            resource_classified_as: Vec<RESOURCECLASSIFIEDAS>,
            /// The primary resource specification or definition of an existing or potential economic resource. A resource will have only one, as this specifies exactly what the resource is.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_conforms_to: Option<RESOURCESPECIFICATION>,
            /// Economic resource involved in the flow.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_inventoried_as: Option<ECONOMICRESOURCE>,
            /// The amount and unit of the economic resource counted or inventoried.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_quantity: Option<om2::Measure>,
            /// An intent satisfied fully or partially by an economic event or commitment.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            satisfies: Option<INTENT>,
            /// References the ProcessSpecification of the last process the economic resource went through. Stage is used when the last process is important for finding proper resources, such as where the publishing process wants only documents that have gone through the editing process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            stage: Option<PROCESSSPECIFICATION>,
            /// The state of the desired economic resource, after coming out of a test or review process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            state: Option<String>,
        }

        impl<AGREEMENT, AGENT, PLAN, PROCESS, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, INTENT, PROCESSSPECIFICATION> Commitment<AGREEMENT, AGENT, PLAN, PROCESS, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, INTENT, PROCESSSPECIFICATION> {
            /// Create an empty builder object for Commitment
            #[allow(dead_code)]
            pub fn builder() -> CommitmentBuilder<AGREEMENT, AGENT, PLAN, PROCESS, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, INTENT, PROCESSSPECIFICATION> {
                // We avoid using CommitmentBuilder::default() here because it requires all our generics to derive Default =[
                CommitmentBuilder {
                    action: 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,
                    note: None,
                    output_of: None,
                    planned_within: None,
                    provider: None,
                    receiver: None,
                    reciprocal_clause_of: None,
                    resource_classified_as: None,
                    resource_conforms_to: None,
                    resource_inventoried_as: None,
                    resource_quantity: None,
                    satisfies: None,
                    stage: None,
                    state: None,
                }
            }

            /// Turns Commitment into CommitmentBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> CommitmentBuilder<AGREEMENT, AGENT, PLAN, PROCESS, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, INTENT, PROCESSSPECIFICATION> {
                let Commitment { action, 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, note, output_of, planned_within, provider, receiver, reciprocal_clause_of, resource_classified_as, resource_conforms_to, resource_inventoried_as, resource_quantity, satisfies, stage, state } = self;
                let mut builder = Self::builder();
                builder = builder.action(action);
                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 note { Some(x) => builder.note(x), None => builder };
                builder = match output_of { Some(x) => builder.output_of(x), None => builder };
                builder = match planned_within { Some(x) => builder.planned_within(x), None => builder };
                builder = builder.provider(provider);
                builder = builder.receiver(receiver);
                builder = match reciprocal_clause_of { Some(x) => builder.reciprocal_clause_of(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 = match satisfies { Some(x) => builder.satisfies(x), None => builder };
                builder = match stage { Some(x) => builder.stage(x), None => builder };
                builder = match state { Some(x) => builder.state(x), None => builder };
                builder
            }
        }
    }
    pub use commitment::Commitment;

    /// The action has this effect on an inventoried resource contained in resource.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#ContainedEffect>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum ContainedEffect {
        /// The effect is to remove or nullify the specified property from the resource.
        #[cfg_attr(feature = "with_serde", serde(rename = "remove"))]
        Remove,
        /// The effect is to update the resource in the specified property.
        #[cfg_attr(feature = "with_serde", serde(rename = "update"))]
        Update,
        /// The effect is to update the to resource in the specified property.
        #[cfg_attr(feature = "with_serde", serde(rename = "update"))]
        UpdateTo,
    }

    /// The action can create an economic resource.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#CreateResource>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum CreateResource {
        /// This kind of flow gives the user the option to create a new resource using resourceInventoriedAs.
        #[cfg_attr(feature = "with_serde", serde(rename = "optional"))]
        Optional,
        /// This kind of flow gives the user the option to create a new resource using toResourceInventoriedAs.
        #[cfg_attr(feature = "with_serde", serde(rename = "optional-to"))]
        OptionalTo,
    }

    mod ecological_agent {
        use super::*;

        /// A non-human being; or a functional group of non-human beings; or an ecosystem of living beings that includes non-humans.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#EcologicalAgent>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct EcologicalAgent<CLASSIFIEDAS> {
            /// References one or more concepts in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            classified_as: Option<CLASSIFIEDAS>,
        }

        impl<CLASSIFIEDAS> EcologicalAgent<CLASSIFIEDAS> {
            /// Create an empty builder object for EcologicalAgent
            #[allow(dead_code)]
            pub fn builder() -> EcologicalAgentBuilder<CLASSIFIEDAS> {
                // We avoid using EcologicalAgentBuilder::default() here because it requires all our generics to derive Default =[
                EcologicalAgentBuilder {
                    classified_as: None,
                }
            }

            /// Turns EcologicalAgent into EcologicalAgentBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> EcologicalAgentBuilder<CLASSIFIEDAS> {
                let EcologicalAgent { classified_as } = self;
                let mut builder = Self::builder();
                builder = match classified_as { Some(x) => builder.classified_as(x), None => builder };
                builder
            }
        }
    }
    pub use ecological_agent::EcologicalAgent;

    mod economic_event {
        use super::*;

        /// An observed economic flow, as opposed to a flow planned to happen in the future. This could reflect a change in the quantity of an economic resource. It is also defined by its behavior in relation to the economic resource (see vf:action)
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#EconomicEvent>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct EconomicEvent<ECONOMICEVENT, COMMITMENT, AGENT, PROCESS, AGREEMENT, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, INTENT, CLAIM> {
            /// Defines the kind of flow, such as consume, produce, work, transfer, etc.
            action: Action,
            /// The place where an intent, commitment, or economic event occurs.  Usually mappable.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            at_location: Option<geo::SpatialThing>,
            /// Used when an event was entered incorrectly and needs to be backed out or corrected. (The initial event cannot be changed.)
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            corrects: Option<ECONOMICEVENT>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            created: Option<DateTime<Utc>>,
            /// The amount and unit of the work or use or citation effort-based action. This is often a time duration, but also could be cycle counts or other measures of effort or usefulness.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            effort_quantity: Option<om2::Measure>,
            /// The commitment which is completely or partially fulfilled by an economic event.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            fulfills: Option<COMMITMENT>,
            /// The planned or actual beginning of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_beginning: Option<DateTime<Utc>>,
            /// The planned or actual end of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_end: Option<DateTime<Utc>>,
            /// The planned or actual time of a flow; can be used instead of hasBeginning and hasEnd, if so, hasBeginning and hasEnd should be able to be returned with this value.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_point_in_time: Option<DateTime<Utc>>,
            /// The uri to an image relevant to the entity, such as a logo, avatar, photo, diagram, etc.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            image: Option<Url>,
            /// In the context of an agent, a grouping generally used for accounting, reporting.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            in_scope_of: Vec<AGENT>,
            /// Relates an input flow to its process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            input_of: Option<PROCESS>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// Relates an output flow to its process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            output_of: Option<PROCESS>,
            /// The economic agent from whom the intended, committed, or actual economic event is initiated.
            provider: AGENT,
            /// This non-reciprocal economic event occurs as part of this agreement.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            realization_of: Option<AGREEMENT>,
            /// The economic agent whom the intended, committed, or actual economic event is for.
            receiver: AGENT,
            /// This reciprocal economic event occurs as part of this agreement.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            reciprocal_realization_of: Option<AGREEMENT>,
            /// References a concept in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            resource_classified_as: Vec<RESOURCECLASSIFIEDAS>,
            /// The primary resource specification or definition of an existing or potential economic resource. A resource will have only one, as this specifies exactly what the resource is.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_conforms_to: Option<RESOURCESPECIFICATION>,
            /// Economic resource involved in the flow.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_inventoried_as: Option<ECONOMICRESOURCE>,
            /// The amount and unit of the economic resource counted or inventoried.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_quantity: Option<om2::Measure>,
            /// An intent satisfied fully or partially by an economic event or commitment.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            satisfies: Option<INTENT>,
            /// References a claim that is fully or partially settled by the economic event.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            settles: Option<CLAIM>,
            /// The state of the desired economic resource, after coming out of a test or review process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            state: Option<String>,
            /// The new location of the receiver resource.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            to_location: Option<geo::SpatialThing>,
            /// Additional economic resource on the economic event when needed by the receiver. Used when a transfer or move, or sometimes other actions, requires explicitly identifying an economic resource on the receiving side.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            to_resource_inventoried_as: Option<ECONOMICRESOURCE>,
            /// References an economic event that implied the claim or event, often based on a prior agreement.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            triggered_by: Option<ECONOMICEVENT>,
        }

        impl<ECONOMICEVENT, COMMITMENT, AGENT, PROCESS, AGREEMENT, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, INTENT, CLAIM> EconomicEvent<ECONOMICEVENT, COMMITMENT, AGENT, PROCESS, AGREEMENT, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, INTENT, CLAIM> {
            /// Create an empty builder object for EconomicEvent
            #[allow(dead_code)]
            pub fn builder() -> EconomicEventBuilder<ECONOMICEVENT, COMMITMENT, AGENT, PROCESS, AGREEMENT, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, INTENT, CLAIM> {
                // We avoid using EconomicEventBuilder::default() here because it requires all our generics to derive Default =[
                EconomicEventBuilder {
                    action: None,
                    at_location: None,
                    corrects: None,
                    created: None,
                    effort_quantity: None,
                    fulfills: 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,
                    reciprocal_realization_of: None,
                    resource_classified_as: None,
                    resource_conforms_to: None,
                    resource_inventoried_as: None,
                    resource_quantity: None,
                    satisfies: None,
                    settles: None,
                    state: None,
                    to_location: None,
                    to_resource_inventoried_as: None,
                    triggered_by: None,
                }
            }

            /// Turns EconomicEvent into EconomicEventBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> EconomicEventBuilder<ECONOMICEVENT, COMMITMENT, AGENT, PROCESS, AGREEMENT, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, INTENT, CLAIM> {
                let EconomicEvent { action, at_location, corrects, created, effort_quantity, fulfills, has_beginning, has_end, has_point_in_time, image, in_scope_of, input_of, note, output_of, provider, realization_of, receiver, reciprocal_realization_of, resource_classified_as, resource_conforms_to, resource_inventoried_as, resource_quantity, satisfies, settles, state, to_location, to_resource_inventoried_as, triggered_by } = self;
                let mut builder = Self::builder();
                builder = builder.action(action);
                builder = match at_location { Some(x) => builder.at_location(x), None => builder };
                builder = match corrects { Some(x) => builder.corrects(x), None => builder };
                builder = match created { Some(x) => builder.created(x), None => builder };
                builder = match effort_quantity { Some(x) => builder.effort_quantity(x), None => builder };
                builder = match fulfills { Some(x) => builder.fulfills(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 = match reciprocal_realization_of { Some(x) => builder.reciprocal_realization_of(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 = match satisfies { Some(x) => builder.satisfies(x), None => builder };
                builder = match settles { Some(x) => builder.settles(x), None => builder };
                builder = match state { Some(x) => builder.state(x), None => builder };
                builder = match to_location { Some(x) => builder.to_location(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::*;

        /// Economic or environmental inputs to or outputs from processes.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#EconomicResource>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct EconomicResource<CLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, AGENT, PROCESSSPECIFICATION> {
            /// The current amount and unit of the economic resource for which the agent has primary rights and responsibilities, sometimes thought of as ownership. This can be either stored or derived from economic events affecting the resource.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            accounting_quantity: Option<om2::Measure>,
            /// References one or more concepts in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            classified_as: Vec<CLASSIFIEDAS>,
            /// The primary resource knowledge specification or definition of an existing or potential resource.
            conforms_to: RESOURCESPECIFICATION,
            /// Used when a stock economic resource contains units also defined as economic resources.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            contained_in: Option<ECONOMICRESOURCE>,
            /// The current place an economic resource is located.  Could be at any level of granularity, from a town to an address to a warehouse location.  Usually mappable.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            current_location: Option<geo::SpatialThing>,
            /// The current virtual place an electronic economic resource is located.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            current_virtual_location: Option<Url>,
            /// If the resource is being tracked as a lot or batch, this is the date the batch expires, after which it is not recommended to use/consume.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            expires_on: Option<DateTime<Utc>>,
            /// The uri to an image relevant to the entity, such as a logo, avatar, photo, diagram, etc.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            image: Option<Url>,
            /// A comma separated list of uri addresses to images relevant to the resource.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            image_list: Option<Url>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            name: Option<String>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// The current amount and unit of the economic resource which is under direct control of the agent.  It may be more or less than the accounting quantity. This can be either stored or derived from economic events affecting the resource.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            onhand_quantity: Option<om2::Measure>,
            /// The agent currently with primary rights and responsibilites for the economic resource. It is the agent that is associated with the accountingQuantity of the economic resource.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            primary_accountable: Option<AGENT>,
            /// References the ProcessSpecification of the last process the economic resource went through. Stage is used when the last process is important for finding proper resources, such as where the publishing process wants only documents that have gone through the editing process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            stage: Option<PROCESSSPECIFICATION>,
            /// The state of the desired economic resource, after coming out of a test or review process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            state: Option<String>,
            /// Any identifier used to track the resource, such as a serial number or VIN or lot/batch identifier.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            tracking_identifier: Option<String>,
            /// The unit used for use or work or sometimes cite actions.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            unit_of_effort: Option<om2::Unit>,
        }

        impl<CLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, AGENT, PROCESSSPECIFICATION> EconomicResource<CLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, AGENT, PROCESSSPECIFICATION> {
            /// Create an empty builder object for EconomicResource
            #[allow(dead_code)]
            pub fn builder() -> EconomicResourceBuilder<CLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, AGENT, PROCESSSPECIFICATION> {
                // We avoid using EconomicResourceBuilder::default() here because it requires all our generics to derive Default =[
                EconomicResourceBuilder {
                    accounting_quantity: None,
                    classified_as: None,
                    conforms_to: None,
                    contained_in: None,
                    current_location: None,
                    current_virtual_location: None,
                    expires_on: None,
                    image: None,
                    image_list: None,
                    name: None,
                    note: None,
                    onhand_quantity: None,
                    primary_accountable: None,
                    stage: None,
                    state: None,
                    tracking_identifier: None,
                    unit_of_effort: None,
                }
            }

            /// Turns EconomicResource into EconomicResourceBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> EconomicResourceBuilder<CLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE, AGENT, PROCESSSPECIFICATION> {
                let EconomicResource { accounting_quantity, classified_as, conforms_to, contained_in, current_location, current_virtual_location, expires_on, image, image_list, 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 current_virtual_location { Some(x) => builder.current_virtual_location(x), None => builder };
                builder = match expires_on { Some(x) => builder.expires_on(x), None => builder };
                builder = match image { Some(x) => builder.image(x), None => builder };
                builder = match image_list { Some(x) => builder.image_list(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;

    /// The action involves the event resource quantity, event quantity, or both.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#EventQuantity>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum EventQuantity {
        /// This event can use resourceQuantity and effortQuantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "both"))]
        Both,
        /// This event uses effortQuantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "effort"))]
        Effort,
        /// This event uses resourceQuantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "resource"))]
        Resource,
    }

    /// The action is an input or output of a process, or not related to a process.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#InputOutput>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum InputOutput {
        /// This kind of flow can be an input to a process.
        #[cfg_attr(feature = "with_serde", serde(rename = "input"))]
        Input,
        /// This kind of flow can be an output to a process.
        #[cfg_attr(feature = "with_serde", serde(rename = "output"))]
        Output,
        /// This kind of flow can be an output to a process, and at the same time an input to another process.
        #[cfg_attr(feature = "with_serde", serde(rename = "output-input"))]
        OutputInput,
    }

    mod intent {
        use super::*;

        /// A proposed or planned or estimated economic flow, prior to a commitment or agreement, which can lead to commitments and/or economic events.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Intent>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Intent<AGENT, PROCESS, PLAN, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
            /// Defines the kind of flow, such as consume, produce, work, transfer, etc.
            action: Action,
            /// The place where an intent, commitment, or economic event occurs.  Usually mappable.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            at_location: Option<geo::SpatialThing>,
            /// The quantity of the offered resource currently available.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            available_quantity: Option<om2::Measure>,
            /// The time something is expected to be complete.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            due: Option<DateTime<Utc>>,
            /// The amount and unit of the work or use or citation effort-based action. This is often a time duration, but also could be cycle counts or other measures of effort or usefulness.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            effort_quantity: Option<om2::Measure>,
            /// The commitment or intent or process is complete or not.  This is irrespective of if the original goal has been met, and indicates that no more will be done.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            finished: Option<bool>,
            /// The planned or actual beginning of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_beginning: Option<DateTime<Utc>>,
            /// The planned or actual end of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_end: Option<DateTime<Utc>>,
            /// The planned or actual time of a flow; can be used instead of hasBeginning and hasEnd, if so, hasBeginning and hasEnd should be able to be returned with this value.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_point_in_time: Option<DateTime<Utc>>,
            /// The uri to an image relevant to the entity, such as a logo, avatar, photo, diagram, etc.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            image: Option<Url>,
            /// A comma separated list of uri addresses to images relevant to the resource.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            image_list: Option<Url>,
            /// In the context of an agent, a grouping generally used for accounting, reporting.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            in_scope_of: Vec<AGENT>,
            /// Relates an input flow to its process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            input_of: Option<PROCESS>,
            /// The minimum required order quantity of the offered resource.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            minimum_quantity: Option<om2::Measure>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// Relates an output flow to its process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            output_of: Option<PROCESS>,
            /// The non-process commitment/intent or process with its inputs and outputs is part of the plan.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            planned_within: Option<PLAN>,
            /// The economic agent from whom the intended, committed, or actual economic event is initiated.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            provider: Option<AGENT>,
            /// The economic agent whom the intended, committed, or actual economic event is for.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            receiver: Option<AGENT>,
            /// References a concept in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            resource_classified_as: Vec<RESOURCECLASSIFIEDAS>,
            /// The primary resource specification or definition of an existing or potential economic resource. A resource will have only one, as this specifies exactly what the resource is.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_conforms_to: Option<RESOURCESPECIFICATION>,
            /// Economic resource involved in the flow.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_inventoried_as: Option<ECONOMICRESOURCE>,
            /// The amount and unit of the economic resource counted or inventoried.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_quantity: Option<om2::Measure>,
        }

        impl<AGENT, PROCESS, PLAN, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE> Intent<AGENT, PROCESS, PLAN, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
            /// Create an empty builder object for Intent
            #[allow(dead_code)]
            pub fn builder() -> IntentBuilder<AGENT, PROCESS, PLAN, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
                // We avoid using IntentBuilder::default() here because it requires all our generics to derive Default =[
                IntentBuilder {
                    action: 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,
                    image_list: None,
                    in_scope_of: None,
                    input_of: None,
                    minimum_quantity: None,
                    note: None,
                    output_of: None,
                    planned_within: None,
                    provider: None,
                    receiver: None,
                    resource_classified_as: None,
                    resource_conforms_to: None,
                    resource_inventoried_as: None,
                    resource_quantity: None,
                }
            }

            /// Turns Intent into IntentBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> IntentBuilder<AGENT, PROCESS, PLAN, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, ECONOMICRESOURCE> {
                let Intent { action, at_location, available_quantity, due, effort_quantity, finished, has_beginning, has_end, has_point_in_time, image, image_list, in_scope_of, input_of, minimum_quantity, note, output_of, planned_within, 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 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 = match image_list { Some(x) => builder.image_list(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 minimum_quantity { Some(x) => builder.minimum_quantity(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 planned_within { Some(x) => builder.planned_within(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;

    /// The action has this effect on an inventoried resource current location.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#LocationEffect>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum LocationEffect {
        /// The effect applies for a new resource created by the event.
        #[cfg_attr(feature = "with_serde", serde(rename = "remove"))]
        New,
        /// The effect is to update the resource in the specified property.
        #[cfg_attr(feature = "with_serde", serde(rename = "update"))]
        Update,
        /// The effect is to update the to resource in the specified property.
        #[cfg_attr(feature = "with_serde", serde(rename = "update"))]
        UpdateTo,
    }

    /// The action has this effect on an inventoried resource onhand quantity.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#OnhandEffect>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum OnhandEffect {
        /// The effect is to subtract from the inventoried resource accounting or onhand quantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "decrement"))]
        Decrement,
        /// The effect is to subtract from the 'from' inventoried resource, and add to the 'to' inventoried resource, accounting or onhand quantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "decrement-increment"))]
        DecrementIncrement,
        /// The effect is to add to the inventoried resource accounting or onhand quantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "increment"))]
        Increment,
        /// The effect is to add to the to (receiver) inventoried resource accounting or onhand quantity.
        #[cfg_attr(feature = "with_serde", serde(rename = "increment-to"))]
        IncrementTo,
    }

    mod organization {
        use super::*;

        /// A functional structure, formal or informal, which can include people and/or other organizations, and has its own agency.  Something called a group is an Organization in Valueflows if it has its own agency.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Organization>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Organization<CLASSIFIEDAS> {
            /// References one or more concepts in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            classified_as: Option<CLASSIFIEDAS>,
        }

        impl<CLASSIFIEDAS> Organization<CLASSIFIEDAS> {
            /// Create an empty builder object for Organization
            #[allow(dead_code)]
            pub fn builder() -> OrganizationBuilder<CLASSIFIEDAS> {
                // We avoid using OrganizationBuilder::default() here because it requires all our generics to derive Default =[
                OrganizationBuilder {
                    classified_as: None,
                }
            }

            /// Turns Organization into OrganizationBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> OrganizationBuilder<CLASSIFIEDAS> {
                let Organization { classified_as } = self;
                let mut builder = Self::builder();
                builder = match classified_as { Some(x) => builder.classified_as(x), None => builder };
                builder
            }
        }
    }
    pub use organization::Organization;

    mod person {
        use super::*;

        /// A human being. All people are considered agents.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Person>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Person {
        }

        impl Person {
            /// Create an empty builder object for Person
            #[allow(dead_code)]
            pub fn builder() -> PersonBuilder {
                // We avoid using PersonBuilder::default() here because it requires all our generics to derive Default =[
                PersonBuilder {
                }
            }

            /// Turns Person into PersonBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> PersonBuilder {
                let Person {  } = self;
                let builder = Self::builder();
                builder
            }
        }
    }
    pub use person::Person;

    mod plan {
        use super::*;

        /// A logical collection of processes that constitute a body of scheduled work with defined deliverable(s).
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Plan>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Plan<COMMITMENT, INTENT, PROCESS, SCENARIO> {
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            created: Option<DateTime<Utc>>,
            /// The time something is expected to be complete.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            due: Option<DateTime<Utc>>,
            /// The independent commitments for which this plan was created.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_independent_demand: Option<COMMITMENT>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            name: Option<String>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// The processes and and non-process commitments/intents that constitute the plan.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            plan_includes: Option<CommitmentIntentProcessUnion<COMMITMENT, INTENT, PROCESS>>,
            /// This scenario or plan refines another scenario, often as time moves closer or for more detail.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            refinement_of: Option<SCENARIO>,
        }

        impl<COMMITMENT, INTENT, PROCESS, SCENARIO> Plan<COMMITMENT, INTENT, PROCESS, SCENARIO> {
            /// Create an empty builder object for Plan
            #[allow(dead_code)]
            pub fn builder() -> PlanBuilder<COMMITMENT, INTENT, PROCESS, SCENARIO> {
                // We avoid using PlanBuilder::default() here because it requires all our generics to derive Default =[
                PlanBuilder {
                    created: None,
                    due: None,
                    has_independent_demand: None,
                    name: None,
                    note: None,
                    plan_includes: None,
                    refinement_of: None,
                }
            }

            /// Turns Plan into PlanBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> PlanBuilder<COMMITMENT, INTENT, PROCESS, SCENARIO> {
                let Plan { created, due, has_independent_demand, name, note, plan_includes, 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 has_independent_demand { Some(x) => builder.has_independent_demand(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 plan_includes { Some(x) => builder.plan_includes(x), None => builder };
                builder = match refinement_of { Some(x) => builder.refinement_of(x), None => builder };
                builder
            }
        }
    }
    pub use plan::Plan;

    mod process {
        use super::*;

        /// An activity that changes inputs into outputs, by transforming or transporting economic resource(s).
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Process>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Process<PROCESSSPECIFICATION, CLASSIFIEDAS, COMMITMENT, ECONOMICEVENT, INTENT, AGENT, SCENARIO, PLAN> {
            /// The definition or standard specification for a process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            based_on: Option<PROCESSSPECIFICATION>,
            /// References one or more concepts in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            classified_as: Vec<CLASSIFIEDAS>,
            /// The commitment or intent or process is complete or not.  This is irrespective of if the original goal has been met, and indicates that no more will be done.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            finished: Option<bool>,
            /// The planned or actual beginning of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_beginning: Option<DateTime<Utc>>,
            /// The planned or actual end of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_end: Option<DateTime<Utc>>,
            /// All the input flows of a process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_input: Option<CommitmentEconomicEventIntentUnion<COMMITMENT, ECONOMICEVENT, INTENT>>,
            /// All the output flows of a process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_output: Option<CommitmentEconomicEventIntentUnion<COMMITMENT, ECONOMICEVENT, INTENT>>,
            /// In the context of an agent, a grouping generally used for accounting, reporting.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            in_scope_of: Vec<AGENT>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            name: String,
            /// The process with its inputs and outputs is part of the scenario.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            nested_in: Option<SCENARIO>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// The non-process commitment/intent or process with its inputs and outputs is part of the plan.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            planned_within: Option<PLAN>,
        }

        impl<PROCESSSPECIFICATION, CLASSIFIEDAS, COMMITMENT, ECONOMICEVENT, INTENT, AGENT, SCENARIO, PLAN> Process<PROCESSSPECIFICATION, CLASSIFIEDAS, COMMITMENT, ECONOMICEVENT, INTENT, AGENT, SCENARIO, PLAN> {
            /// Create an empty builder object for Process
            #[allow(dead_code)]
            pub fn builder() -> ProcessBuilder<PROCESSSPECIFICATION, CLASSIFIEDAS, COMMITMENT, ECONOMICEVENT, INTENT, AGENT, SCENARIO, PLAN> {
                // We avoid using ProcessBuilder::default() here because it requires all our generics to derive Default =[
                ProcessBuilder {
                    based_on: None,
                    classified_as: None,
                    finished: None,
                    has_beginning: None,
                    has_end: None,
                    has_input: None,
                    has_output: None,
                    in_scope_of: None,
                    name: None,
                    nested_in: None,
                    note: None,
                    planned_within: None,
                }
            }

            /// Turns Process into ProcessBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> ProcessBuilder<PROCESSSPECIFICATION, CLASSIFIEDAS, COMMITMENT, ECONOMICEVENT, INTENT, AGENT, SCENARIO, PLAN> {
                let Process { based_on, classified_as, finished, has_beginning, has_end, has_input, has_output, 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 = match has_input { Some(x) => builder.has_input(x), None => builder };
                builder = match has_output { Some(x) => builder.has_output(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::*;

        /// Specifies the kind of process.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#ProcessSpecification>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct ProcessSpecification {
            /// The uri to an image relevant to the entity, such as a logo, avatar, photo, diagram, etc.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            image: Option<Url>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            name: String,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
        }

        impl ProcessSpecification {
            /// Create an empty builder object for ProcessSpecification
            #[allow(dead_code)]
            pub fn builder() -> ProcessSpecificationBuilder {
                // We avoid using ProcessSpecificationBuilder::default() here because it requires all our generics to derive Default =[
                ProcessSpecificationBuilder {
                    image: None,
                    name: None,
                    note: None,
                }
            }

            /// Turns ProcessSpecification into ProcessSpecificationBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> ProcessSpecificationBuilder {
                let ProcessSpecification { image, name, note } = 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
            }
        }
    }
    pub use process_specification::ProcessSpecification;

    mod proposal {
        use super::*;

        /// Published requests or offers, sometimes with what is expected in return.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Proposal>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Proposal<AGENT, PROPOSALLIST, INTENT> {
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            created: Option<DateTime<Utc>>,
            /// Location or area where the proposal is valid.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            eligible_location: Option<geo::SpatialThing>,
            /// The planned or actual beginning of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_beginning: Option<DateTime<Utc>>,
            /// The planned or actual end of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_end: Option<DateTime<Utc>>,
            /// In the context of an agent, a grouping generally used for accounting, reporting.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            in_scope_of: Vec<AGENT>,
            /// This proposal is part of a list of proposals.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            listed_in: Option<PROPOSALLIST>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            name: Option<String>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// The agent(s) to which the proposal is published.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            proposed_to: Option<AGENT>,
            /// The primary intent(s) of this published proposal. Would be used in intent matching.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            publishes: Option<INTENT>,
            /// The type of proposal, offer or request.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            purpose: Option<ProposalPurpose>,
            /// The reciprocal intent(s) of this published proposal. Not meant to be used for intent matching.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            reciprocal: Option<INTENT>,
            /// This proposal contains unit based quantities, which can be multipied to create commitments; commonly seen in a price list or e-commerce.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            unit_based: Option<bool>,
        }

        impl<AGENT, PROPOSALLIST, INTENT> Proposal<AGENT, PROPOSALLIST, INTENT> {
            /// Create an empty builder object for Proposal
            #[allow(dead_code)]
            pub fn builder() -> ProposalBuilder<AGENT, PROPOSALLIST, INTENT> {
                // We avoid using ProposalBuilder::default() here because it requires all our generics to derive Default =[
                ProposalBuilder {
                    created: None,
                    eligible_location: None,
                    has_beginning: None,
                    has_end: None,
                    in_scope_of: None,
                    listed_in: None,
                    name: None,
                    note: None,
                    proposed_to: None,
                    publishes: None,
                    purpose: None,
                    reciprocal: None,
                    unit_based: None,
                }
            }

            /// Turns Proposal into ProposalBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> ProposalBuilder<AGENT, PROPOSALLIST, INTENT> {
                let Proposal { created, eligible_location, has_beginning, has_end, in_scope_of, listed_in, name, note, proposed_to, publishes, purpose, reciprocal, 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 listed_in { Some(x) => builder.listed_in(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 proposed_to { Some(x) => builder.proposed_to(x), None => builder };
                builder = match publishes { Some(x) => builder.publishes(x), None => builder };
                builder = match purpose { Some(x) => builder.purpose(x), None => builder };
                builder = match reciprocal { Some(x) => builder.reciprocal(x), None => builder };
                builder = match unit_based { Some(x) => builder.unit_based(x), None => builder };
                builder
            }
        }
    }
    pub use proposal::Proposal;

    mod proposal_list {
        use super::*;

        /// A grouping of proposals, for publishing as a list.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#ProposalList>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct ProposalList<PROPOSAL> {
            /// All the proposals included in this proposal list.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            lists: Vec<PROPOSAL>,
        }

        impl<PROPOSAL> ProposalList<PROPOSAL> {
            /// Create an empty builder object for ProposalList
            #[allow(dead_code)]
            pub fn builder() -> ProposalListBuilder<PROPOSAL> {
                // We avoid using ProposalListBuilder::default() here because it requires all our generics to derive Default =[
                ProposalListBuilder {
                    lists: None,
                }
            }

            /// Turns ProposalList into ProposalListBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> ProposalListBuilder<PROPOSAL> {
                let ProposalList { lists } = self;
                let mut builder = Self::builder();
                builder = builder.lists(lists);
                builder
            }
        }
    }
    pub use proposal_list::ProposalList;

    /// The type of proposal, an offer or request (others may be added).
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#ProposalPurpose>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum ProposalPurpose {
        /// The proposal is an offer.
        #[cfg_attr(feature = "with_serde", serde(rename = "offer"))]
        Offer,
        /// The proposal is a published request, need, want.
        #[cfg_attr(feature = "with_serde", serde(rename = "request"))]
        Request,
    }

    mod recipe_exchange {
        use super::*;

        /// Specifies an exchange type agreement as part of a recipe.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#RecipeExchange>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct RecipeExchange<RECIPEFLOW> {
            /// All the primary clauses of a recipe exchange.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            recipe_stipulates: Option<RECIPEFLOW>,
            /// All the reciprocal clauses of a recipe exchange.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            recipe_stipulates_reciprocal: Option<RECIPEFLOW>,
        }

        impl<RECIPEFLOW> RecipeExchange<RECIPEFLOW> {
            /// Create an empty builder object for RecipeExchange
            #[allow(dead_code)]
            pub fn builder() -> RecipeExchangeBuilder<RECIPEFLOW> {
                // We avoid using RecipeExchangeBuilder::default() here because it requires all our generics to derive Default =[
                RecipeExchangeBuilder {
                    recipe_stipulates: None,
                    recipe_stipulates_reciprocal: None,
                }
            }

            /// Turns RecipeExchange into RecipeExchangeBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> RecipeExchangeBuilder<RECIPEFLOW> {
                let RecipeExchange { recipe_stipulates, recipe_stipulates_reciprocal } = self;
                let mut builder = Self::builder();
                builder = match recipe_stipulates { Some(x) => builder.recipe_stipulates(x), None => builder };
                builder = match recipe_stipulates_reciprocal { Some(x) => builder.recipe_stipulates_reciprocal(x), None => builder };
                builder
            }
        }
    }
    pub use recipe_exchange::RecipeExchange;

    mod recipe_flow {
        use super::*;

        /// The specification of a resource inflow to, or outflow from, a recipe process.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#RecipeFlow>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct RecipeFlow<RECIPEEXCHANGE, RECIPEPROCESS, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, PROCESSSPECIFICATION> {
            /// Defines the kind of flow, such as consume, produce, work, transfer, etc.
            action: Action,
            /// The amount and unit of the work or use or citation effort-based action. This is often a time duration, but also could be cycle counts or other measures of effort or usefulness.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            effort_quantity: Option<om2::Measure>,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// Relates a flow to its exchange agreement in a recipe.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            recipe_clause_of: Option<RECIPEEXCHANGE>,
            /// Relates an input flow to its process in a recipe.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            recipe_input_of: Option<RECIPEPROCESS>,
            /// Relates an output flow to its process in a recipe.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            recipe_output_of: Option<RECIPEPROCESS>,
            /// Relates a reciprocal flow to its exchange agreement in a recipe.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            recipe_reciprocal_clause_of: Option<RECIPEEXCHANGE>,
            /// References a concept in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_classified_as: Option<RESOURCECLASSIFIEDAS>,
            /// The primary resource specification or definition of an existing or potential economic resource. A resource will have only one, as this specifies exactly what the resource is.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_conforms_to: Option<RESOURCESPECIFICATION>,
            /// The amount and unit of the economic resource counted or inventoried.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            resource_quantity: Option<om2::Measure>,
            /// References the ProcessSpecification of the last process the economic resource went through. Stage is used when the last process is important for finding proper resources, such as where the publishing process wants only documents that have gone through the editing process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            stage: Option<PROCESSSPECIFICATION>,
            /// The state of the desired economic resource, after coming out of a test or review process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            state: Option<String>,
        }

        impl<RECIPEEXCHANGE, RECIPEPROCESS, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, PROCESSSPECIFICATION> RecipeFlow<RECIPEEXCHANGE, RECIPEPROCESS, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, PROCESSSPECIFICATION> {
            /// Create an empty builder object for RecipeFlow
            #[allow(dead_code)]
            pub fn builder() -> RecipeFlowBuilder<RECIPEEXCHANGE, RECIPEPROCESS, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, PROCESSSPECIFICATION> {
                // We avoid using RecipeFlowBuilder::default() here because it requires all our generics to derive Default =[
                RecipeFlowBuilder {
                    action: None,
                    effort_quantity: None,
                    note: None,
                    recipe_clause_of: None,
                    recipe_input_of: None,
                    recipe_output_of: None,
                    recipe_reciprocal_clause_of: None,
                    resource_classified_as: None,
                    resource_conforms_to: None,
                    resource_quantity: None,
                    stage: None,
                    state: None,
                }
            }

            /// Turns RecipeFlow into RecipeFlowBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> RecipeFlowBuilder<RECIPEEXCHANGE, RECIPEPROCESS, RESOURCECLASSIFIEDAS, RESOURCESPECIFICATION, PROCESSSPECIFICATION> {
                let RecipeFlow { action, effort_quantity, note, recipe_clause_of, recipe_input_of, recipe_output_of, recipe_reciprocal_clause_of, resource_classified_as, resource_conforms_to, resource_quantity, stage, state } = 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_clause_of { Some(x) => builder.recipe_clause_of(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 recipe_reciprocal_clause_of { Some(x) => builder.recipe_reciprocal_clause_of(x), None => builder };
                builder = match resource_classified_as { Some(x) => builder.resource_classified_as(x), None => builder };
                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 = match stage { Some(x) => builder.stage(x), None => builder };
                builder = match state { Some(x) => builder.state(x), None => builder };
                builder
            }
        }
    }
    pub use recipe_flow::RecipeFlow;

    mod recipe_process {
        use super::*;

        /// Specifies a process in a recipe for use in planning from recipe.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#RecipeProcess>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct RecipeProcess<RECIPEFLOW, PROCESSCLASSIFIEDAS, PROCESSSPECIFICATION> {
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_duration: Option<Duration>,
            /// All the inputs of a recipe process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_recipe_input: Option<RECIPEFLOW>,
            /// All the outputs of a recipe process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_recipe_output: Option<RECIPEFLOW>,
            /// The uri to an image relevant to the entity, such as a logo, avatar, photo, diagram, etc.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            image: Option<Url>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            name: String,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// References a concept in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            process_classified_as: Vec<PROCESSCLASSIFIEDAS>,
            /// The standard specification or definition of a process.
            process_conforms_to: PROCESSSPECIFICATION,
        }

        impl<RECIPEFLOW, PROCESSCLASSIFIEDAS, PROCESSSPECIFICATION> RecipeProcess<RECIPEFLOW, PROCESSCLASSIFIEDAS, PROCESSSPECIFICATION> {
            /// Create an empty builder object for RecipeProcess
            #[allow(dead_code)]
            pub fn builder() -> RecipeProcessBuilder<RECIPEFLOW, PROCESSCLASSIFIEDAS, PROCESSSPECIFICATION> {
                // We avoid using RecipeProcessBuilder::default() here because it requires all our generics to derive Default =[
                RecipeProcessBuilder {
                    has_duration: None,
                    has_recipe_input: None,
                    has_recipe_output: None,
                    image: None,
                    name: None,
                    note: None,
                    process_classified_as: None,
                    process_conforms_to: None,
                }
            }

            /// Turns RecipeProcess into RecipeProcessBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> RecipeProcessBuilder<RECIPEFLOW, PROCESSCLASSIFIEDAS, PROCESSSPECIFICATION> {
                let RecipeProcess { has_duration, has_recipe_input, has_recipe_output, image, 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 = match has_recipe_input { Some(x) => builder.has_recipe_input(x), None => builder };
                builder = match has_recipe_output { Some(x) => builder.has_recipe_output(x), None => 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.process_classified_as(process_classified_as);
                builder = builder.process_conforms_to(process_conforms_to);
                builder
            }
        }
    }
    pub use recipe_process::RecipeProcess;

    mod resource_specification {
        use super::*;

        /// Specifies the kind of resource, even if the resource is not instantiated as an EconomicResource. Could define a material item, service, digital item, currency account, skill or type of work, etc.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#ResourceSpecification>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct ResourceSpecification<RESOURCECLASSIFIEDAS> {
            /// The default unit used for use or work.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            default_unit_of_effort: Option<om2::Unit>,
            /// The default unit used for the resource itself.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            default_unit_of_resource: Option<om2::Unit>,
            /// The uri to an image relevant to the entity, such as a logo, avatar, photo, diagram, etc.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            image: Option<Url>,
            /// A comma separated list of uri addresses to images relevant to the resource.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            image_list: Option<Url>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            name: String,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// References a concept in a common taxonomy or other classification scheme for purposes of categorization or grouping.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            resource_classified_as: Vec<RESOURCECLASSIFIEDAS>,
            /// Defines if any resource of that type can be freely substituted for any other resource of that type when used, consumed, traded, etc.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            substitutable: Option<bool>,
        }

        impl<RESOURCECLASSIFIEDAS> ResourceSpecification<RESOURCECLASSIFIEDAS> {
            /// Create an empty builder object for ResourceSpecification
            #[allow(dead_code)]
            pub fn builder() -> ResourceSpecificationBuilder<RESOURCECLASSIFIEDAS> {
                // We avoid using ResourceSpecificationBuilder::default() here because it requires all our generics to derive Default =[
                ResourceSpecificationBuilder {
                    default_unit_of_effort: None,
                    default_unit_of_resource: None,
                    image: None,
                    image_list: None,
                    name: None,
                    note: None,
                    resource_classified_as: None,
                    substitutable: None,
                }
            }

            /// Turns ResourceSpecification into ResourceSpecificationBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> ResourceSpecificationBuilder<RESOURCECLASSIFIEDAS> {
                let ResourceSpecification { default_unit_of_effort, default_unit_of_resource, image, image_list, name, note, resource_classified_as, substitutable } = self;
                let mut builder = Self::builder();
                builder = match default_unit_of_effort { Some(x) => builder.default_unit_of_effort(x), None => builder };
                builder = match default_unit_of_resource { Some(x) => builder.default_unit_of_resource(x), None => builder };
                builder = match image { Some(x) => builder.image(x), None => builder };
                builder = match image_list { Some(x) => builder.image_list(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 substitutable { Some(x) => builder.substitutable(x), None => builder };
                builder
            }
        }
    }
    pub use resource_specification::ResourceSpecification;

    /// The general shape or behavior grouping of an agent relationship role.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#RoleBehavior>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum RoleBehavior {
        /// The role is a member type role in relation to an organization.  An agent can be a member of many organizations.
        #[cfg_attr(feature = "with_serde", serde(rename = "member"))]
        Member,
        /// The role is a peer type role in relation to an agent. Examples are trading partners or mentors.
        #[cfg_attr(feature = "with_serde", serde(rename = "peer"))]
        Peer,
        /// The role is a sub-organization type role in relation to an organization. An agent can be a sub-organization of no more than one organization.
        #[cfg_attr(feature = "with_serde", serde(rename = "sub-organization"))]
        SubOrganization,
    }

    impl RoleBehavior {
        #[allow(dead_code)]
        pub fn name(&self) -> Option<String> {
            match self {
                _ => None,
            }
        }

        #[allow(dead_code)]
        pub fn note(&self) -> Option<String> {
            match self {
                _ => None,
            }
        }

    }

    mod scenario {
        use super::*;

        /// An estimated or analytical logical collection of higher level processes used for budgeting, analysis, plan refinement, etc.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#Scenario>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct Scenario<SCENARIODEFINITION, AGENT, SCENARIO> {
            /// The scenario definition for this scenario, for example yearly budget.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            defined_as: Option<SCENARIODEFINITION>,
            /// The planned or actual beginning of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_beginning: Option<DateTime<Utc>>,
            /// The planned or actual end of a flow or process.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_end: Option<DateTime<Utc>>,
            /// In the context of an agent, a grouping generally used for accounting, reporting.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Vec::is_empty"))]
            #[builder(default)]
            in_scope_of: Vec<AGENT>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            name: String,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
            /// This scenario or plan refines another scenario, often as time moves closer or for more detail.
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            refinement_of: Option<SCENARIO>,
        }

        impl<SCENARIODEFINITION, AGENT, SCENARIO> Scenario<SCENARIODEFINITION, AGENT, SCENARIO> {
            /// Create an empty builder object for Scenario
            #[allow(dead_code)]
            pub fn builder() -> ScenarioBuilder<SCENARIODEFINITION, AGENT, SCENARIO> {
                // We avoid using ScenarioBuilder::default() here because it requires all our generics to derive Default =[
                ScenarioBuilder {
                    defined_as: None,
                    has_beginning: None,
                    has_end: None,
                    in_scope_of: None,
                    name: None,
                    note: None,
                    refinement_of: None,
                }
            }

            /// Turns Scenario into ScenarioBuilder
            #[allow(dead_code)]
            pub fn into_builder(self) -> ScenarioBuilder<SCENARIODEFINITION, AGENT, 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::*;

        /// The type definition of one or more scenarios.
        ///
        /// ID: <https://w3id.org/valueflows/ont/vf#ScenarioDefinition>
        #[derive(Debug, Clone, PartialEq, Builder, Getters)]
        #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
        #[derive(Setters)]
        #[derive(MutGetters)]
        #[builder(pattern = "owned", setter(into))]
        #[getset(get = "pub", set = "pub", get_mut = "pub")]
        pub struct ScenarioDefinition {
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            has_duration: Option<Duration>,
            /// An informal or formal textual identifier for an object. Does not imply uniqueness.
            name: String,
            #[cfg_attr(feature = "with_serde", serde(default = "Default::default", skip_serializing_if = "Option::is_none"))]
            #[builder(default)]
            note: Option<String>,
        }

        impl ScenarioDefinition {
            /// Create an empty builder object for ScenarioDefinition
            #[allow(dead_code)]
            pub fn builder() -> ScenarioDefinitionBuilder {
                // We avoid using ScenarioDefinitionBuilder::default() here because it requires all our generics to derive Default =[
                ScenarioDefinitionBuilder {
                    has_duration: None,
                    name: None,
                    note: None,
                }
            }

            /// Turns ScenarioDefinition into ScenarioDefinitionBuilder
            #[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;

    /// The action has this effect on an inventoried resource stage.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#StageEffect>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum StageEffect {
        /// The effect is to update the resource in the specified property.
        #[cfg_attr(feature = "with_serde", serde(rename = "update"))]
        Update,
    }

    /// The action has this effect on an inventoried resource state.
    ///
    /// ID: <https://w3id.org/valueflows/ont/vf#StateEffect>
    #[derive(Debug, PartialEq, Clone)]
    #[cfg_attr(feature = "with_serde", derive(Serialize, Deserialize))]
    pub enum StateEffect {
        /// The effect is to update the resource in the specified property.
        #[cfg_attr(feature = "with_serde", serde(rename = "update"))]
        Update,
        /// The effect is to update the to resource in the specified property.
        #[cfg_attr(feature = "with_serde", serde(rename = "update"))]
        UpdateTo,
    }

    /// Holds the supporting builder structs for our vf types. Create a builder via `SomeType::builder()`.
    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::agreement_bundle::AgreementBundleBuilder;
        pub use super::appreciation::AppreciationBuilder;
        pub use super::claim::ClaimBuilder;
        pub use super::commitment::CommitmentBuilder;
        pub use super::ecological_agent::EcologicalAgentBuilder;
        pub use super::economic_event::EconomicEventBuilder;
        pub use super::economic_resource::EconomicResourceBuilder;
        pub use super::intent::IntentBuilder;
        pub use super::organization::OrganizationBuilder;
        pub use super::person::PersonBuilder;
        pub use super::plan::PlanBuilder;
        pub use super::process::ProcessBuilder;
        pub use super::process_specification::ProcessSpecificationBuilder;
        pub use super::proposal::ProposalBuilder;
        pub use super::proposal_list::ProposalListBuilder;
        pub use super::recipe_exchange::RecipeExchangeBuilder;
        pub use super::recipe_flow::RecipeFlowBuilder;
        pub use super::recipe_process::RecipeProcessBuilder;
        pub use super::resource_specification::ResourceSpecificationBuilder;
        pub use super::scenario::ScenarioBuilder;
        pub use super::scenario_definition::ScenarioDefinitionBuilder;
    }
}