dfc-linkml-connector 2.0.6

data/lib/models/order_line.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #OrderLine
+require_relative '../core/semantic_object'
+
+
+module DfcLinkmlConnector
+  module Models
+    class OrderLine < Core::SemanticObject
+      SEMANTIC_TYPE = "dfc-b:OrderLine".freeze
+
+      # @return [Float]
+      attr_accessor :discount
+
+      # @return [Float]
+      attr_accessor :quantity
+
+      # @return [String]
+      attr_accessor :concerns
+
+      # @return [String]
+      attr_accessor :price
+
+      # @return [String]
+      attr_accessor :is_fulfilled_by
+
+      # @return [String]
+      attr_accessor :date
+
+      # @return [String]
+      attr_accessor :description
+
+      # @return [String]
+      attr_accessor :name
+
+      # @return [String]
+      attr_accessor :characteristic_of
+
+      # @return [String]
+      attr_accessor :dimension
+
+      # @return [QuantitativeValue, String]
+      attr_accessor :has_quantity
+
+      # @return [Order, String]
+      attr_accessor :part_of
+
+      # @param semanticId [String]
+      # @param discount: nil, quantity: nil, concerns: nil, price: nil, isFulfilledBy: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hasQuantity: nil, partOf: nil
+      def initialize(semanticId, discount: nil, quantity: nil, concerns: nil, price: nil, isFulfilledBy: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hasQuantity: nil, partOf: nil)
+        super(semanticId)
+        @discount = discount
+        @quantity = quantity
+        @concerns = concerns
+        @price = price
+        @is_fulfilled_by = isFulfilledBy
+        @date = date
+        @description = description
+        @name = name
+        @characteristic_of = characteristicOf
+        @dimension = dimension
+        @has_quantity = hasQuantity
+        @part_of = partOf
+        self.semanticType = "dfc-b:OrderLine"
+        registerSemanticProperty("dfc-b:discount", &method("discount")).valueSetter = method("discount=")
+        registerSemanticProperty("dfc-b:quantity", &method("quantity")).valueSetter = method("quantity=")
+        registerSemanticProperty("dfc-b:concerns", &method("concerns")).valueSetter = method("concerns=")
+        registerSemanticProperty("dfc-b:hasPrice", &method("price")).valueSetter = method("price=")
+        registerSemanticProperty("dfc-b:isFulfilledBy", &method("is_fulfilled_by")).valueSetter = method("is_fulfilled_by=")
+        registerSemanticProperty("dfc-b:date", &method("date")).valueSetter = method("date=")
+        registerSemanticProperty("dfc-b:description", &method("description")).valueSetter = method("description=")
+        registerSemanticProperty("dfc-b:name", &method("name")).valueSetter = method("name=")
+        registerSemanticProperty("dfc-b:characteristicOf", &method("characteristic_of")).valueSetter = method("characteristic_of=")
+        registerSemanticProperty("dfc-b:hasDimension", &method("dimension")).valueSetter = method("dimension=")
+        registerSemanticProperty("dfc-b:hasQuantity", &method("has_quantity")).valueSetter = method("has_quantity=")
+        registerSemanticProperty("dfc-b:partOf", &method("part_of")).valueSetter = method("part_of=")
+      end
+
+      # Original DFC v2 API aliases (see config/dfc-original-api.yaml).
+      alias_method :offer, :concerns
+      alias_method :offer=, :concerns=
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/organization.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Organization
+require_relative '../core/semantic_object'
+require_relative 'agent'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Organization < Agent
+      SEMANTIC_TYPE = "dfc-b:Organization".freeze
+
+      # @return [String]
+      attr_accessor :vat_number
+
+      # @return [Boolean]
+      attr_accessor :vat_status
+
+      # @return [String]
+      attr_accessor :enterprise_id
+
+      # @return [String]
+      attr_accessor :template_sale_session
+
+      # @return [String]
+      attr_accessor :is_certified_by
+
+      # @return [Array<Organization, String>]
+      attr_accessor :affiliates
+
+      # @return [Array<CustomerCategory, String>]
+      attr_accessor :defines
+
+      # @return [Person, String]
+      attr_accessor :main_contact
+
+      # @return [Array<Catalog, String>]
+      attr_accessor :maintains
+
+      # @return [Array<CatalogItem, String>]
+      attr_accessor :manages
+
+      # @return [Array<TechnicalProduct, String>]
+      attr_accessor :proposes
+
+      # @return [Array<SuppliedProduct, String>]
+      attr_accessor :supplies
+
+      # @return [Array<AsPlannedLocalTransformation, String>]
+      attr_accessor :transforms
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, email: nil, logo: nil, websitePage: nil, hasPhoneNumber: nil, socialMedia: nil, owns: nil, sells: nil, affiliatedTo: nil, address: [], isMemberOf: [], orders: [], requests: [], vatNumber: nil, vatStatus: nil, enterpriseId: nil, templateSaleSession: nil, isCertifiedBy: nil, affiliates: [], defines: [], mainContact: nil, maintains: [], manages: [], proposes: [], supplies: [], transforms: []
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, email: nil, logo: nil, websitePage: nil, hasPhoneNumber: nil, socialMedia: nil, owns: nil, sells: nil, affiliatedTo: nil, address: [], isMemberOf: [], orders: [], requests: [], vatNumber: nil, vatStatus: nil, enterpriseId: nil, templateSaleSession: nil, isCertifiedBy: nil, affiliates: [], defines: [], mainContact: nil, maintains: [], manages: [], proposes: [], supplies: [], transforms: [])
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension, email: email, logo: logo, websitePage: websitePage, hasPhoneNumber: hasPhoneNumber, socialMedia: socialMedia, owns: owns, sells: sells, affiliatedTo: affiliatedTo, address: address, isMemberOf: isMemberOf, orders: orders, requests: requests)
+        @vat_number = vatNumber
+        @vat_status = vatStatus
+        @enterprise_id = enterpriseId
+        @template_sale_session = templateSaleSession
+        @is_certified_by = isCertifiedBy
+        @affiliates = affiliates
+        @defines = defines
+        @main_contact = mainContact
+        @maintains = maintains
+        @manages = manages
+        @proposes = proposes
+        @supplies = supplies
+        @transforms = transforms
+        self.semanticType = "dfc-b:Organization"
+        registerSemanticProperty("dfc-b:VATnumber", &method("vat_number")).valueSetter = method("vat_number=")
+        registerSemanticProperty("dfc-b:VATstatus", &method("vat_status")).valueSetter = method("vat_status=")
+        registerSemanticProperty("dfc-b:enterpriseID", &method("enterprise_id")).valueSetter = method("enterprise_id=")
+        registerSemanticProperty("dfc-b:hasTemplateSaleSession", &method("template_sale_session")).valueSetter = method("template_sale_session=")
+        registerSemanticProperty("dfc-b:isCertifiedBy", &method("is_certified_by")).valueSetter = method("is_certified_by=")
+        registerSemanticProperty("dfc-b:affiliates", &method("affiliates")).valueSetter = method("affiliates=")
+        registerSemanticProperty("dfc-b:defines", &method("defines")).valueSetter = method("defines=")
+        registerSemanticProperty("dfc-b:hasMainContact", &method("main_contact")).valueSetter = method("main_contact=")
+        registerSemanticProperty("dfc-b:maintains", &method("maintains")).valueSetter = method("maintains=")
+        registerSemanticProperty("dfc-b:manages", &method("manages")).valueSetter = method("manages=")
+        registerSemanticProperty("dfc-b:proposes", &method("proposes")).valueSetter = method("proposes=")
+        registerSemanticProperty("dfc-b:supplies", &method("supplies")).valueSetter = method("supplies=")
+        registerSemanticProperty("dfc-b:transforms", &method("transforms")).valueSetter = method("transforms=")
+      end
+
+      # Original DFC v2 API aliases (see config/dfc-original-api.yaml).
+      alias_method :vatNumber, :vat_number
+      alias_method :vatNumber=, :vat_number=
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/payment_method.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #PaymentMethod
+require_relative '../core/semantic_object'
+require_relative 'how_subject'
+
+
+module DfcLinkmlConnector
+  module Models
+    class PaymentMethod < HowSubject
+      SEMANTIC_TYPE = "dfc-b:PaymentMethod".freeze
+
+      # @return [String]
+      attr_accessor :payment_method_provider
+
+      # @return [String]
+      attr_accessor :payment_method_type
+
+      # @return [String]
+      attr_accessor :price
+
+      # @return [String]
+      attr_accessor :paid_with
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, paymentMethodProvider: nil, paymentMethodType: nil, price: nil, paidWith: nil
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, paymentMethodProvider: nil, paymentMethodType: nil, price: nil, paidWith: nil)
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+        @payment_method_provider = paymentMethodProvider
+        @payment_method_type = paymentMethodType
+        @price = price
+        @paid_with = paidWith
+        self.semanticType = "dfc-b:PaymentMethod"
+        registerSemanticProperty("dfc-b:paymentMethodProvider", &method("payment_method_provider")).valueSetter = method("payment_method_provider=")
+        registerSemanticProperty("dfc-b:paymentMethodType", &method("payment_method_type")).valueSetter = method("payment_method_type=")
+        registerSemanticProperty("dfc-b:hasPrice", &method("price")).valueSetter = method("price=")
+        registerSemanticProperty("dfc-b:paidWith", &method("paid_with")).valueSetter = method("paid_with=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/person.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Person
+require_relative '../core/semantic_object'
+require_relative 'agent'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Person < Agent
+      SEMANTIC_TYPE = "dfc-b:Person".freeze
+
+      # @return [String]
+      attr_accessor :family_name
+
+      # @return [String]
+      attr_accessor :first_name
+
+      # @return [String]
+      attr_accessor :main_contact_of
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, email: nil, logo: nil, websitePage: nil, hasPhoneNumber: nil, socialMedia: nil, owns: nil, sells: nil, affiliatedTo: nil, address: [], isMemberOf: [], orders: [], requests: [], familyName: nil, firstName: nil, mainContactOf: nil
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, email: nil, logo: nil, websitePage: nil, hasPhoneNumber: nil, socialMedia: nil, owns: nil, sells: nil, affiliatedTo: nil, address: [], isMemberOf: [], orders: [], requests: [], familyName: nil, firstName: nil, mainContactOf: nil)
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension, email: email, logo: logo, websitePage: websitePage, hasPhoneNumber: hasPhoneNumber, socialMedia: socialMedia, owns: owns, sells: sells, affiliatedTo: affiliatedTo, address: address, isMemberOf: isMemberOf, orders: orders, requests: requests)
+        @family_name = familyName
+        @first_name = firstName
+        @main_contact_of = mainContactOf
+        self.semanticType = "dfc-b:Person"
+        registerSemanticProperty("dfc-b:familyName", &method("family_name")).valueSetter = method("family_name=")
+        registerSemanticProperty("dfc-b:firstName", &method("first_name")).valueSetter = method("first_name=")
+        registerSemanticProperty("dfc-b:mainContactOf", &method("main_contact_of")).valueSetter = method("main_contact_of=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/phone_number.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #PhoneNumber
+require_relative '../core/semantic_object'
+require_relative 'what_subject'
+
+
+module DfcLinkmlConnector
+  module Models
+    class PhoneNumber < WhatSubject
+      SEMANTIC_TYPE = "dfc-b:PhoneNumber".freeze
+
+      # @return [String]
+      attr_accessor :country_code
+
+      # @return [String]
+      attr_accessor :phone_number
+
+      # @return [String]
+      attr_accessor :phone_number_of
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, countryCode: nil, phoneNumber: nil, phoneNumberOf: nil
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, countryCode: nil, phoneNumber: nil, phoneNumberOf: nil)
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+        @country_code = countryCode
+        @phone_number = phoneNumber
+        @phone_number_of = phoneNumberOf
+        self.semanticType = "dfc-b:PhoneNumber"
+        registerSemanticProperty("dfc-b:countryCode", &method("country_code")).valueSetter = method("country_code=")
+        registerSemanticProperty("dfc-b:phoneNumber", &method("phone_number")).valueSetter = method("phone_number=")
+        registerSemanticProperty("dfc-b:phoneNumberOf", &method("phone_number_of")).valueSetter = method("phone_number_of=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/physical_characteristic.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #PhysicalCharacteristic
+require_relative '../core/semantic_object'
+
+
+module DfcLinkmlConnector
+  module Models
+    class PhysicalCharacteristic < Core::SemanticObject
+      SEMANTIC_TYPE = "dfc-b:PhysicalCharacteristic".freeze
+
+      # @return [String]
+      attr_accessor :physical_characteristic_of
+
+      # @return [String]
+      attr_accessor :date
+
+      # @return [String]
+      attr_accessor :description
+
+      # @return [String]
+      attr_accessor :name
+
+      # @return [String]
+      attr_accessor :characteristic_of
+
+      # @return [String]
+      attr_accessor :dimension
+
+      # @return [Concept, String]
+      attr_accessor :physical_dimension
+
+      # @param semanticId [String]
+      # @param physicalCharacteristicOf: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, physicalDimension: nil
+      def initialize(semanticId, physicalCharacteristicOf: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, physicalDimension: nil)
+        super(semanticId)
+        @physical_characteristic_of = physicalCharacteristicOf
+        @date = date
+        @description = description
+        @name = name
+        @characteristic_of = characteristicOf
+        @dimension = dimension
+        @physical_dimension = physicalDimension
+        self.semanticType = "dfc-b:PhysicalCharacteristic"
+        registerSemanticProperty("dfc-b:physicalCharacteristicOf", &method("physical_characteristic_of")).valueSetter = method("physical_characteristic_of=")
+        registerSemanticProperty("dfc-b:date", &method("date")).valueSetter = method("date=")
+        registerSemanticProperty("dfc-b:description", &method("description")).valueSetter = method("description=")
+        registerSemanticProperty("dfc-b:name", &method("name")).valueSetter = method("name=")
+        registerSemanticProperty("dfc-b:characteristicOf", &method("characteristic_of")).valueSetter = method("characteristic_of=")
+        registerSemanticProperty("dfc-b:hasDimension", &method("dimension")).valueSetter = method("dimension=")
+        registerSemanticProperty("dfc-b:hasPhysicalDimension", &method("physical_dimension")).valueSetter = method("physical_dimension=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/physical_place.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #PhysicalPlace
+require_relative '../core/semantic_object'
+require_relative 'place'
+
+
+module DfcLinkmlConnector
+  module Models
+    class PhysicalPlace < Place
+      SEMANTIC_TYPE = "dfc-b:PhysicalPlace".freeze
+
+      # @return [String]
+      attr_accessor :has_phone_number
+
+      # @return [Address, String]
+      attr_accessor :address
+
+      # @return [Array<Feature, String>]
+      attr_accessor :geo_json_feature
+
+      # @return [Array<Person, String>]
+      attr_accessor :main_contact
+
+      # @return [OpeningHoursSpecification, String]
+      attr_accessor :is_open_during
+
+      # @return [Array<TheoriticalStock, String>]
+      attr_accessor :localizes
+
+      # @return [Array<RealStock, String>]
+      attr_accessor :stores
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hosts: [], hasPhoneNumber: nil, address: nil, geoJsonFeature: [], mainContact: [], isOpenDuring: nil, localizes: [], stores: []
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hosts: [], hasPhoneNumber: nil, address: nil, geoJsonFeature: [], mainContact: [], isOpenDuring: nil, localizes: [], stores: [])
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension, hosts: hosts)
+        @has_phone_number = hasPhoneNumber
+        @address = address
+        @geo_json_feature = geoJsonFeature
+        @main_contact = mainContact
+        @is_open_during = isOpenDuring
+        @localizes = localizes
+        @stores = stores
+        self.semanticType = "dfc-b:PhysicalPlace"
+        registerSemanticProperty("dfc-b:hasPhoneNumber", &method("has_phone_number")).valueSetter = method("has_phone_number=")
+        registerSemanticProperty("dfc-b:hasAddress", &method("address")).valueSetter = method("address=")
+        registerSemanticProperty("dfc-b:hasGeoJsonFeature", &method("geo_json_feature")).valueSetter = method("geo_json_feature=")
+        registerSemanticProperty("dfc-b:hasMainContact", &method("main_contact")).valueSetter = method("main_contact=")
+        registerSemanticProperty("dfc-b:isOpenDuring", &method("is_open_during")).valueSetter = method("is_open_during=")
+        registerSemanticProperty("dfc-b:localizes", &method("localizes")).valueSetter = method("localizes=")
+        registerSemanticProperty("dfc-b:stores", &method("stores")).valueSetter = method("stores=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/physical_product.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #PhysicalProduct
+require_relative '../core/semantic_object'
+require_relative 'what_subject'
+
+
+module DfcLinkmlConnector
+  module Models
+    class PhysicalProduct < WhatSubject
+      SEMANTIC_TYPE = "dfc-b:PhysicalProduct".freeze
+
+      # @return [String]
+      attr_accessor :image
+
+      # @return [Float]
+      attr_accessor :quantity
+
+      # @return [String]
+      attr_accessor :concerned_by
+
+      # @return [String]
+      attr_accessor :constitued_by
+
+      # @return [String]
+      attr_accessor :consumed_by
+
+      # @return [String]
+      attr_accessor :fulfills
+
+      # @return [String]
+      attr_accessor :produced_by
+
+      # @return [QuantitativeValue, String]
+      attr_accessor :has_quantity
+
+      # @return [Agent, String]
+      attr_accessor :owned_by
+
+      # @return [Array<LocalizedProduct, String>]
+      attr_accessor :represents
+
+      # @return [Array<ProductBatch, String>]
+      attr_accessor :traced_by
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, image: nil, quantity: nil, concernedBy: nil, constituedBy: nil, consumedBy: nil, fulfills: nil, producedBy: nil, hasQuantity: nil, ownedBy: nil, represents: [], tracedBy: []
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, image: nil, quantity: nil, concernedBy: nil, constituedBy: nil, consumedBy: nil, fulfills: nil, producedBy: nil, hasQuantity: nil, ownedBy: nil, represents: [], tracedBy: [])
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+        @image = image
+        @quantity = quantity
+        @concerned_by = concernedBy
+        @constitued_by = constituedBy
+        @consumed_by = consumedBy
+        @fulfills = fulfills
+        @produced_by = producedBy
+        @has_quantity = hasQuantity
+        @owned_by = ownedBy
+        @represents = represents
+        @traced_by = tracedBy
+        self.semanticType = "dfc-b:PhysicalProduct"
+        registerSemanticProperty("dfc-b:Image", &method("image")).valueSetter = method("image=")
+        registerSemanticProperty("dfc-b:quantity", &method("quantity")).valueSetter = method("quantity=")
+        registerSemanticProperty("dfc-b:concernedBy", &method("concerned_by")).valueSetter = method("concerned_by=")
+        registerSemanticProperty("dfc-b:constituedBy", &method("constitued_by")).valueSetter = method("constitued_by=")
+        registerSemanticProperty("dfc-b:consumedBy", &method("consumed_by")).valueSetter = method("consumed_by=")
+        registerSemanticProperty("dfc-b:fulfills", &method("fulfills")).valueSetter = method("fulfills=")
+        registerSemanticProperty("dfc-b:producedBy", &method("produced_by")).valueSetter = method("produced_by=")
+        registerSemanticProperty("dfc-b:hasQuantity", &method("has_quantity")).valueSetter = method("has_quantity=")
+        registerSemanticProperty("dfc-b:ownedBy", &method("owned_by")).valueSetter = method("owned_by=")
+        registerSemanticProperty("dfc-b:represents", &method("represents")).valueSetter = method("represents=")
+        registerSemanticProperty("dfc-b:tracedBy", &method("traced_by")).valueSetter = method("traced_by=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/pick_up_step.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #PickUpStep
+require_relative '../core/semantic_object'
+require_relative 'step'
+
+
+module DfcLinkmlConnector
+  module Models
+    class PickUpStep < Step
+      SEMANTIC_TYPE = "dfc-b:PickUpStep".freeze
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, arrivalDate: nil, duration: nil, isStepOf: nil, delivery: [], pickUp: []
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, arrivalDate: nil, duration: nil, isStepOf: nil, delivery: [], pickUp: [])
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension, arrivalDate: arrivalDate, duration: duration, isStepOf: isStepOf, delivery: delivery, pickUp: pickUp)
+
+        self.semanticType = "dfc-b:PickUpStep"
+
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/pickup_option.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #PickupOption
+require_relative '../core/semantic_object'
+require_relative 'shipping_option'
+
+
+module DfcLinkmlConnector
+  module Models
+    class PickupOption < ShippingOption
+      SEMANTIC_TYPE = "dfc-b:PickupOption".freeze
+
+      # @return [String]
+      attr_accessor :picked_up_at
+
+      # @return [String]
+      attr_accessor :uses
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, endDate: nil, fee: nil, quantity: nil, startDate: nil, selectedBy: nil, hasQuantity: nil, optionOf: nil, pickedUpAt: nil, uses: nil
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, endDate: nil, fee: nil, quantity: nil, startDate: nil, selectedBy: nil, hasQuantity: nil, optionOf: nil, pickedUpAt: nil, uses: nil)
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension, endDate: endDate, fee: fee, quantity: quantity, startDate: startDate, selectedBy: selectedBy, hasQuantity: hasQuantity, optionOf: optionOf)
+        @picked_up_at = pickedUpAt
+        @uses = uses
+        self.semanticType = "dfc-b:PickupOption"
+        registerSemanticProperty("dfc-b:pickedUpAt", &method("picked_up_at")).valueSetter = method("picked_up_at=")
+        registerSemanticProperty("dfc-b:uses", &method("uses")).valueSetter = method("uses=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/place.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Place
+require_relative '../core/semantic_object'
+require_relative 'where_subject'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Place < WhereSubject
+      SEMANTIC_TYPE = "dfc-b:Place".freeze
+
+      # @return [Array<SaleSession, String>]
+      attr_accessor :hosts
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hosts: []
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hosts: [])
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+        @hosts = hosts
+        self.semanticType = "dfc-b:Place"
+        registerSemanticProperty("dfc-b:hosts", &method("hosts")).valueSetter = method("hosts=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/platform.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Platform
+require_relative '../core/semantic_object'
+require_relative 'ditributed_representation'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Platform < DitributedRepresentation
+      SEMANTIC_TYPE = "dfc-b:Platform".freeze
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil)
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+
+        self.semanticType = "dfc-b:Platform"
+
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/point.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Point
+require_relative '../core/semantic_object'
+require_relative 'geometry'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Point < Geometry
+      SEMANTIC_TYPE = "dfc-b:Point".freeze
+
+      # @param semanticId [String]
+      # @param coordinates: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil
+      def initialize(semanticId, coordinates: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil)
+        super(semanticId, coordinates: coordinates, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+
+        self.semanticType = "dfc-b:Point"
+
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/polygon.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Polygon
+require_relative '../core/semantic_object'
+require_relative 'geometry'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Polygon < Geometry
+      SEMANTIC_TYPE = "dfc-b:Polygon".freeze
+
+      # @param semanticId [String]
+      # @param coordinates: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil
+      def initialize(semanticId, coordinates: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil)
+        super(semanticId, coordinates: coordinates, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+
+        self.semanticType = "dfc-b:Polygon"
+
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end