dfc-linkml-connector 2.0.6

data/lib/models/price.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Price
+require_relative '../core/semantic_object'
+require_relative 'quantitative_value'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Price < QuantitativeValue
+      SEMANTIC_TYPE = "dfc-b:Price".freeze
+
+      # @return [Float]
+      attr_accessor :vat_rate
+
+      # @return [String]
+      attr_accessor :is_price_of
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, value: nil, unit: nil, vatRate: nil, isPriceOf: nil
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, value: nil, unit: nil, vatRate: nil, isPriceOf: nil)
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension, value: value, unit: unit)
+        @vat_rate = vatRate
+        @is_price_of = isPriceOf
+        self.semanticType = "dfc-b:Price"
+        registerSemanticProperty("dfc-b:VATrate", &method("vat_rate")).valueSetter = method("vat_rate=")
+        registerSemanticProperty("dfc-b:isPriceOf", &method("is_price_of")).valueSetter = method("is_price_of=")
+      end
+
+      # Original DFC v2 API aliases (see config/dfc-original-api.yaml).
+      alias_method :vatRate, :vat_rate
+      alias_method :vatRate=, :vat_rate=
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/product_batch.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #ProductBatch
+require_relative '../core/semantic_object'
+require_relative 'what_subject'
+
+
+module DfcLinkmlConnector
+  module Models
+    class ProductBatch < WhatSubject
+      SEMANTIC_TYPE = "dfc-b:ProductBatch".freeze
+
+      # @return [String]
+      attr_accessor :batch_number
+
+      # @return [String]
+      attr_accessor :best_before_date
+
+      # @return [String]
+      attr_accessor :expiry_date
+
+      # @return [String]
+      attr_accessor :production_date
+
+      # @return [Array<RealStock, String>]
+      attr_accessor :identifies
+
+      # @return [Array<PhysicalProduct, String>]
+      attr_accessor :traces
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, batchNumber: nil, bestBeforeDate: nil, expiryDate: nil, productionDate: nil, identifies: [], traces: []
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, batchNumber: nil, bestBeforeDate: nil, expiryDate: nil, productionDate: nil, identifies: [], traces: [])
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+        @batch_number = batchNumber
+        @best_before_date = bestBeforeDate
+        @expiry_date = expiryDate
+        @production_date = productionDate
+        @identifies = identifies
+        @traces = traces
+        self.semanticType = "dfc-b:ProductBatch"
+        registerSemanticProperty("dfc-b:batchNumber", &method("batch_number")).valueSetter = method("batch_number=")
+        registerSemanticProperty("dfc-b:bestBeforeDate", &method("best_before_date")).valueSetter = method("best_before_date=")
+        registerSemanticProperty("dfc-b:expiryDate", &method("expiry_date")).valueSetter = method("expiry_date=")
+        registerSemanticProperty("dfc-b:productionDate", &method("production_date")).valueSetter = method("production_date=")
+        registerSemanticProperty("dfc-b:identifies", &method("identifies")).valueSetter = method("identifies=")
+        registerSemanticProperty("dfc-b:traces", &method("traces")).valueSetter = method("traces=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/product_option.rb

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

data/lib/models/product_option_value.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #ProductOptionValue
+require_relative '../core/semantic_object'
+require_relative 'what_subject'
+
+
+module DfcLinkmlConnector
+  module Models
+    class ProductOptionValue < WhatSubject
+      SEMANTIC_TYPE = "dfc-b:ProductOptionValue".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:ProductOptionValue"
+
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/production_flow.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #ProductionFlow
+require_relative '../core/semantic_object'
+
+
+module DfcLinkmlConnector
+  module Models
+    class ProductionFlow < Core::SemanticObject
+      SEMANTIC_TYPE = "dfc-b:ProductionFlow".freeze
+
+      # @return [Float]
+      attr_accessor :quantity
+
+      # @return [String]
+      attr_accessor :output_of
+
+      # @return [String]
+      attr_accessor :produces
+
+      # @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
+
+      # @param semanticId [String]
+      # @param quantity: nil, outputOf: nil, produces: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hasQuantity: nil
+      def initialize(semanticId, quantity: nil, outputOf: nil, produces: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hasQuantity: nil)
+        super(semanticId)
+        @quantity = quantity
+        @output_of = outputOf
+        @produces = produces
+        @date = date
+        @description = description
+        @name = name
+        @characteristic_of = characteristicOf
+        @dimension = dimension
+        @has_quantity = hasQuantity
+        self.semanticType = "dfc-b:ProductionFlow"
+        registerSemanticProperty("dfc-b:quantity", &method("quantity")).valueSetter = method("quantity=")
+        registerSemanticProperty("dfc-b:outputOf", &method("output_of")).valueSetter = method("output_of=")
+        registerSemanticProperty("dfc-b:produces", &method("produces")).valueSetter = method("produces=")
+        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=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/properties.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Properties
+require_relative '../core/semantic_object'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Properties < Core::SemanticObject
+      SEMANTIC_TYPE = "dfc-b:Properties".freeze
+
+      # @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
+
+      # @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
+        @characteristic_of = characteristicOf
+        @dimension = dimension
+        self.semanticType = "dfc-b:Properties"
+        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=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/quantitative_value.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #QuantitativeValue
+require_relative '../core/semantic_object'
+require_relative 'represented_thing'
+
+
+module DfcLinkmlConnector
+  module Models
+    class QuantitativeValue < RepresentedThing
+      SEMANTIC_TYPE = "dfc-b:QuantitativeValue".freeze
+
+      # @return [Float]
+      attr_accessor :value
+
+      # @return [String]
+      attr_accessor :unit
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, value: nil, unit: nil
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, value: nil, unit: nil)
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+        @value = value
+        @unit = unit
+        self.semanticType = "dfc-b:QuantitativeValue"
+        registerSemanticProperty("dfc-b:value", &method("value")).valueSetter = method("value=")
+        registerSemanticProperty("dfc-b:hasUnit", &method("unit")).valueSetter = method("unit=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/real_stock.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #RealStock
+require_relative '../core/semantic_object'
+require_relative 'stock'
+
+
+module DfcLinkmlConnector
+  module Models
+    class RealStock < Stock
+      SEMANTIC_TYPE = "dfc-b:RealStock".freeze
+
+      # @return [String]
+      attr_accessor :constitutes
+
+      # @return [ProductBatch, String]
+      attr_accessor :identified_by
+
+      # @return [PhysicalPlace, String]
+      attr_accessor :stored_in
+
+      # @param semanticId [String]
+      # @param availabilityDate: nil, quantity: nil, transportedBy: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hasQuantity: nil, constitutes: nil, identifiedBy: nil, storedIn: nil
+      def initialize(semanticId, availabilityDate: nil, quantity: nil, transportedBy: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hasQuantity: nil, constitutes: nil, identifiedBy: nil, storedIn: nil)
+        super(semanticId, availabilityDate: availabilityDate, quantity: quantity, transportedBy: transportedBy, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension, hasQuantity: hasQuantity)
+        @constitutes = constitutes
+        @identified_by = identifiedBy
+        @stored_in = storedIn
+        self.semanticType = "dfc-b:RealStock"
+        registerSemanticProperty("dfc-b:constitutes", &method("constitutes")).valueSetter = method("constitutes=")
+        registerSemanticProperty("dfc-b:identifiedBy", &method("identified_by")).valueSetter = method("identified_by=")
+        registerSemanticProperty("dfc-b:storedIn", &method("stored_in")).valueSetter = method("stored_in=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/representation_pivot.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #RepresentationPivot
+require_relative '../core/semantic_object'
+require_relative 'ditributed_representation'
+
+
+module DfcLinkmlConnector
+  module Models
+    class RepresentationPivot < DitributedRepresentation
+      SEMANTIC_TYPE = "dfc-b:RepresentationPivot".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:RepresentationPivot"
+
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/represented_thing.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #RepresentedThing
+require_relative '../core/semantic_object'
+require_relative 'ditributed_representation'
+
+
+module DfcLinkmlConnector
+  module Models
+    class RepresentedThing < DitributedRepresentation
+      SEMANTIC_TYPE = "dfc-b:RepresentedThing".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:RepresentedThing"
+
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/route.rb

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

data/lib/models/sale_session.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #SaleSession
+require_relative '../core/semantic_object'
+
+
+module DfcLinkmlConnector
+  module Models
+    class SaleSession < Core::SemanticObject
+      SEMANTIC_TYPE = "dfc-b:SaleSession".freeze
+
+      # @return [String]
+      attr_accessor :end_date
+
+      # @return [Float]
+      attr_accessor :quantity
+
+      # @return [String]
+      attr_accessor :start_date
+
+      # @return [String]
+      attr_accessor :holds
+
+      # @return [String]
+      attr_accessor :lists
+
+      # @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 [ShippingOption, String]
+      attr_accessor :option
+
+      # @return [QuantitativeValue, String]
+      attr_accessor :has_quantity
+
+      # @return [Array<Place, String>]
+      attr_accessor :hosted_at
+
+      # @return [Coordination, String]
+      attr_accessor :object_of
+
+      # @param semanticId [String]
+      # @param endDate: nil, quantity: nil, startDate: nil, holds: nil, lists: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, option: nil, hasQuantity: nil, hostedAt: [], objectOf: nil
+      def initialize(semanticId, endDate: nil, quantity: nil, startDate: nil, holds: nil, lists: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, option: nil, hasQuantity: nil, hostedAt: [], objectOf: nil)
+        super(semanticId)
+        @end_date = endDate
+        @quantity = quantity
+        @start_date = startDate
+        @holds = holds
+        @lists = lists
+        @date = date
+        @description = description
+        @name = name
+        @characteristic_of = characteristicOf
+        @dimension = dimension
+        @option = option
+        @has_quantity = hasQuantity
+        @hosted_at = hostedAt
+        @object_of = objectOf
+        self.semanticType = "dfc-b:SaleSession"
+        registerSemanticProperty("dfc-b:endDate", &method("end_date")).valueSetter = method("end_date=")
+        registerSemanticProperty("dfc-b:quantity", &method("quantity")).valueSetter = method("quantity=")
+        registerSemanticProperty("dfc-b:startDate", &method("start_date")).valueSetter = method("start_date=")
+        registerSemanticProperty("dfc-b:holds", &method("holds")).valueSetter = method("holds=")
+        registerSemanticProperty("dfc-b:lists", &method("lists")).valueSetter = method("lists=")
+        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:hasOption", &method("option")).valueSetter = method("option=")
+        registerSemanticProperty("dfc-b:hasQuantity", &method("has_quantity")).valueSetter = method("has_quantity=")
+        registerSemanticProperty("dfc-b:hostedAt", &method("hosted_at")).valueSetter = method("hosted_at=")
+        registerSemanticProperty("dfc-b:objectOf", &method("object_of")).valueSetter = method("object_of=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/shipment.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Shipment
+require_relative '../core/semantic_object'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Shipment < Core::SemanticObject
+      SEMANTIC_TYPE = "dfc-b:Shipment".freeze
+
+      # @return [String]
+      attr_accessor :end_date
+
+      # @return [String]
+      attr_accessor :start_date
+
+      # @return [String]
+      attr_accessor :is_shipped_in
+
+      # @return [String]
+      attr_accessor :transports
+
+      # @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 [PhysicalPlace, String]
+      attr_accessor :ends_at
+
+      # @return [PhysicalPlace, String]
+      attr_accessor :starts_at
+
+      # @param semanticId [String]
+      # @param endDate: nil, startDate: nil, isShippedIn: nil, transports: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, endsAt: nil, startsAt: nil
+      def initialize(semanticId, endDate: nil, startDate: nil, isShippedIn: nil, transports: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, endsAt: nil, startsAt: nil)
+        super(semanticId)
+        @end_date = endDate
+        @start_date = startDate
+        @is_shipped_in = isShippedIn
+        @transports = transports
+        @date = date
+        @description = description
+        @name = name
+        @characteristic_of = characteristicOf
+        @dimension = dimension
+        @ends_at = endsAt
+        @starts_at = startsAt
+        self.semanticType = "dfc-b:Shipment"
+        registerSemanticProperty("dfc-b:endDate", &method("end_date")).valueSetter = method("end_date=")
+        registerSemanticProperty("dfc-b:startDate", &method("start_date")).valueSetter = method("start_date=")
+        registerSemanticProperty("dfc-b:isShippedIn", &method("is_shipped_in")).valueSetter = method("is_shipped_in=")
+        registerSemanticProperty("dfc-b:transports", &method("transports")).valueSetter = method("transports=")
+        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:endsAt", &method("ends_at")).valueSetter = method("ends_at=")
+        registerSemanticProperty("dfc-b:startsAt", &method("starts_at")).valueSetter = method("starts_at=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/shipping_option.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #ShippingOption
+require_relative '../core/semantic_object'
+require_relative 'how_subject'
+
+
+module DfcLinkmlConnector
+  module Models
+    class ShippingOption < HowSubject
+      SEMANTIC_TYPE = "dfc-b:ShippingOption".freeze
+
+      # @return [String]
+      attr_accessor :end_date
+
+      # @return [Float]
+      attr_accessor :fee
+
+      # @return [Float]
+      attr_accessor :quantity
+
+      # @return [String]
+      attr_accessor :start_date
+
+      # @return [String]
+      attr_accessor :selected_by
+
+      # @return [QuantitativeValue, String]
+      attr_accessor :has_quantity
+
+      # @return [SaleSession, String]
+      attr_accessor :option_of
+
+      # @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
+      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)
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+        @end_date = endDate
+        @fee = fee
+        @quantity = quantity
+        @start_date = startDate
+        @selected_by = selectedBy
+        @has_quantity = hasQuantity
+        @option_of = optionOf
+        self.semanticType = "dfc-b:ShippingOption"
+        registerSemanticProperty("dfc-b:endDate", &method("end_date")).valueSetter = method("end_date=")
+        registerSemanticProperty("dfc-b:fee", &method("fee")).valueSetter = method("fee=")
+        registerSemanticProperty("dfc-b:quantity", &method("quantity")).valueSetter = method("quantity=")
+        registerSemanticProperty("dfc-b:startDate", &method("start_date")).valueSetter = method("start_date=")
+        registerSemanticProperty("dfc-b:selectedBy", &method("selected_by")).valueSetter = method("selected_by=")
+        registerSemanticProperty("dfc-b:hasQuantity", &method("has_quantity")).valueSetter = method("has_quantity=")
+        registerSemanticProperty("dfc-b:optionOf", &method("option_of")).valueSetter = method("option_of=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end