agentic-commerce-protocol 0.1.3 → 0.1.5

data/lib/agentic_commerce_protocol/models/line_item.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module AgenticCommerceProtocol
+  class LineItem
+    attr_accessor :id
+    attr_accessor :item
+    attr_accessor :base_amount
+    attr_accessor :discount
+    attr_accessor :subtotal
+    attr_accessor :tax
+    attr_accessor :total
+
+    ALL_FIELD ||= ["id", "item", "base_amount", "discount", "subtotal", "tax", "total"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `AgenticCommerceProtocol::LineItem` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of AgenticCommerceProtocol::LineItem")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["id"] = attributes["id"]
+      attrs["item"] = AgenticCommerceProtocol::Item.deserialize(attributes["item"])
+      attrs["base_amount"] = attributes["base_amount"]
+      attrs["discount"] = attributes["discount"]
+      attrs["subtotal"] = attributes["subtotal"]
+      attrs["tax"] = attributes["tax"]
+      attrs["total"] = attributes["total"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["id"] = AgenticCommerceProtocol::serialize_primitive(@id) if @id
+      out["item"] = AgenticCommerceProtocol::serialize_schema_ref(@item) if @item
+      out["base_amount"] = AgenticCommerceProtocol::serialize_primitive(@base_amount) if @base_amount
+      out["discount"] = AgenticCommerceProtocol::serialize_primitive(@discount) if @discount
+      out["subtotal"] = AgenticCommerceProtocol::serialize_primitive(@subtotal) if @subtotal
+      out["tax"] = AgenticCommerceProtocol::serialize_primitive(@tax) if @tax
+      out["total"] = AgenticCommerceProtocol::serialize_primitive(@total) if @total
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/agentic_commerce_protocol/models/link.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module AgenticCommerceProtocol
+  class Link
+    attr_accessor :type
+    attr_accessor :url
+
+    ALL_FIELD ||= ["type", "url"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `AgenticCommerceProtocol::Link` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of AgenticCommerceProtocol::Link")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["type"] = AgenticCommerceProtocol::LinkType.deserialize(attributes["type"])
+      attrs["url"] = attributes["url"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["type"] = AgenticCommerceProtocol::serialize_schema_ref(@type) if @type
+      out["url"] = AgenticCommerceProtocol::serialize_primitive(@url) if @url
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/agentic_commerce_protocol/models/link_type.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# This file is @generated
+module AgenticCommerceProtocol
+  class LinkType
+    TERMS_OF_USE = "terms_of_use".freeze
+    PRIVACY_POLICY = "privacy_policy".freeze
+    SELLER_SHOP_POLICIES = "seller_shop_policies".freeze
+
+    def self.all_vars
+      @all_vars ||= [TERMS_OF_USE, PRIVACY_POLICY, SELLER_SHOP_POLICIES].freeze
+    end
+
+    def initialize(value)
+      unless LinkType.all_vars.include?(value)
+        raise "Invalid ENUM value '#{value}' for class #LinkType"
+      end
+
+      @value = value
+    end
+
+    def self.deserialize(value)
+      return value if LinkType.all_vars.include?(value)
+      raise "Invalid ENUM value '#{value}' for class #LinkType"
+    end
+
+    def serialize
+      @value
+    end
+  end
+end

data/lib/agentic_commerce_protocol/models/message.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+require_relative "./message_error"
+require_relative "./message_info"
+
+module AgenticCommerceProtocol
+  class MessageData
+    class Info < MessageInfo
+    end
+
+    class Error < MessageError
+    end
+  end
+
+  class Message
+    attr_accessor :data
+
+    ALL_FIELD ||= ["data"].freeze
+    private_constant :ALL_FIELD
+    TYPE_TO_NAME = {
+      MessageData::Info => "info",
+      MessageData::Error => "error"
+    }
+    private_constant :TYPE_TO_NAME
+    NAME_TO_TYPE = TYPE_TO_NAME.invert
+    private_constant :NAME_TO_TYPE
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `AgenticCommerceProtocol::Message` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of AgenticCommerceProtocol::Message")
+        end
+
+        if k == "data"
+          unless TYPE_TO_NAME.key?(v.class)
+            fail(ArgumentError, "The field #{k} can't be a `#{v.class}` expected one of #{TYPE_TO_NAME.keys}")
+          end
+
+          instance_variable_set("@__enum_discriminator", TYPE_TO_NAME[v.class])
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+
+      if @__enum_discriminator.nil?
+        fail(ArgumentError, "Required data field was not set")
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      unless NAME_TO_TYPE.key?(attributes["type"])
+        fail(ArgumentError, "Invalid type `#{attributes["type"]}` expected on of #{NAME_TO_TYPE.keys}")
+      end
+
+      unless attributes.key?("data")
+        fail(ArgumentError, "Missing required field data")
+      end
+
+      attrs["data"] = NAME_TO_TYPE[attributes["type"]].deserialize(attributes["data"])
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["type"] = @__enum_discriminator
+      out["data"] = @data.serialize
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+
+  end
+end

data/lib/agentic_commerce_protocol/models/message_error.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module AgenticCommerceProtocol
+  class MessageError
+    attr_accessor :code
+    attr_accessor :param
+    attr_accessor :content_type
+    attr_accessor :content
+
+    ALL_FIELD ||= ["code", "param", "content_type", "content"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `AgenticCommerceProtocol::MessageError` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of AgenticCommerceProtocol::MessageError")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["code"] = AgenticCommerceProtocol::ErrorCode.deserialize(attributes["code"])
+      attrs["param"] = attributes["param"]
+      attrs["content_type"] = AgenticCommerceProtocol::ContentType.deserialize(attributes["content_type"])
+      attrs["content"] = attributes["content"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["code"] = AgenticCommerceProtocol::serialize_schema_ref(@code) if @code
+      out["param"] = AgenticCommerceProtocol::serialize_primitive(@param) if @param
+      out["content_type"] = AgenticCommerceProtocol::serialize_schema_ref(@content_type) if @content_type
+      out["content"] = AgenticCommerceProtocol::serialize_primitive(@content) if @content
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/agentic_commerce_protocol/models/message_info.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module AgenticCommerceProtocol
+  class MessageInfo
+    attr_accessor :param
+    attr_accessor :content_type
+    attr_accessor :content
+
+    ALL_FIELD ||= ["param", "content_type", "content"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `AgenticCommerceProtocol::MessageInfo` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of AgenticCommerceProtocol::MessageInfo")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["param"] = attributes["param"]
+      attrs["content_type"] = AgenticCommerceProtocol::ContentType.deserialize(attributes["content_type"])
+      attrs["content"] = attributes["content"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["param"] = AgenticCommerceProtocol::serialize_primitive(@param) if @param
+      out["content_type"] = AgenticCommerceProtocol::serialize_schema_ref(@content_type) if @content_type
+      out["content"] = AgenticCommerceProtocol::serialize_primitive(@content) if @content
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/agentic_commerce_protocol/models/order.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module AgenticCommerceProtocol
+  class Order
+    attr_accessor :id
+    attr_accessor :checkout_session_id
+    attr_accessor :permalink_url
+
+    ALL_FIELD ||= ["id", "checkout_session_id", "permalink_url"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `AgenticCommerceProtocol::Order` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of AgenticCommerceProtocol::Order")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["id"] = attributes["id"]
+      attrs["checkout_session_id"] = attributes["checkout_session_id"]
+      attrs["permalink_url"] = attributes["permalink_url"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["id"] = AgenticCommerceProtocol::serialize_primitive(@id) if @id
+      if @checkout_session_id
+        out["checkout_session_id"] = AgenticCommerceProtocol::serialize_primitive(@checkout_session_id)
+      end
+
+      out["permalink_url"] = AgenticCommerceProtocol::serialize_primitive(@permalink_url) if @permalink_url
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/agentic_commerce_protocol/models/payment_data.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module AgenticCommerceProtocol
+  class PaymentData
+    attr_accessor :token
+    attr_accessor :provider
+    attr_accessor :billing_address
+
+    ALL_FIELD ||= ["token", "provider", "billing_address"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `AgenticCommerceProtocol::PaymentData` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of AgenticCommerceProtocol::PaymentData")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["token"] = attributes["token"]
+      attrs["provider"] = AgenticCommerceProtocol::PaymentProviderType.deserialize(attributes["provider"])
+      if attributes["billing_address"]
+        attrs["billing_address"] = AgenticCommerceProtocol::Address.deserialize(attributes["billing_address"])
+      end
+
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["token"] = AgenticCommerceProtocol::serialize_primitive(@token) if @token
+      out["provider"] = AgenticCommerceProtocol::serialize_schema_ref(@provider) if @provider
+      out["billing_address"] = AgenticCommerceProtocol::serialize_schema_ref(@billing_address) if @billing_address
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/agentic_commerce_protocol/models/payment_method_card.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module AgenticCommerceProtocol
+  class PaymentMethodCard
+    attr_accessor :type
+    attr_accessor :card_number_type
+    attr_accessor :number
+    attr_accessor :exp_month
+    attr_accessor :exp_year
+    attr_accessor :name
+    attr_accessor :cvc
+    attr_accessor :cryptogram
+    attr_accessor :eci_value
+    attr_accessor :checks_performed
+    attr_accessor :iin
+    attr_accessor :display_card_funding_type
+    attr_accessor :display_wallet_type
+    attr_accessor :display_brand
+    attr_accessor :display_last4
+    attr_accessor :metadata
+
+    ALL_FIELD ||= [
+      "type",
+      "card_number_type",
+      "number",
+      "exp_month",
+      "exp_year",
+      "name",
+      "cvc",
+      "cryptogram",
+      "eci_value",
+      "checks_performed",
+      "iin",
+      "display_card_funding_type",
+      "display_wallet_type",
+      "display_brand",
+      "display_last4",
+      "metadata"
+    ].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `AgenticCommerceProtocol::PaymentMethodCard` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of AgenticCommerceProtocol::PaymentMethodCard")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["type"] = attributes["type"]
+      attrs["card_number_type"] = AgenticCommerceProtocol::CardNumberType.deserialize(attributes["card_number_type"])
+      attrs["number"] = attributes["number"]
+      attrs["exp_month"] = attributes["exp_month"]
+      attrs["exp_year"] = attributes["exp_year"]
+      attrs["name"] = attributes["name"]
+      attrs["cvc"] = attributes["cvc"]
+      attrs["cryptogram"] = attributes["cryptogram"]
+      attrs["eci_value"] = attributes["eci_value"]
+      if attributes["checks_performed"]
+        attrs["checks_performed"] = attributes["checks_performed"].map { |v|
+          AgenticCommerceProtocol::CheckPerformedType.deserialize(v)
+        }
+      end
+
+      attrs["iin"] = attributes["iin"]
+      attrs["display_card_funding_type"] = AgenticCommerceProtocol::CardFundingType.deserialize(
+        attributes["display_card_funding_type"]
+      )
+      attrs["display_wallet_type"] = attributes["display_wallet_type"]
+      attrs["display_brand"] = attributes["display_brand"]
+      attrs["display_last4"] = attributes["display_last4"]
+      attrs["metadata"] = attributes["metadata"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["type"] = AgenticCommerceProtocol::serialize_primitive(@type) if @type
+      out["card_number_type"] = AgenticCommerceProtocol::serialize_schema_ref(@card_number_type) if @card_number_type
+      out["number"] = AgenticCommerceProtocol::serialize_primitive(@number) if @number
+      out["exp_month"] = AgenticCommerceProtocol::serialize_primitive(@exp_month) if @exp_month
+      out["exp_year"] = AgenticCommerceProtocol::serialize_primitive(@exp_year) if @exp_year
+      out["name"] = AgenticCommerceProtocol::serialize_primitive(@name) if @name
+      out["cvc"] = AgenticCommerceProtocol::serialize_primitive(@cvc) if @cvc
+      out["cryptogram"] = AgenticCommerceProtocol::serialize_primitive(@cryptogram) if @cryptogram
+      out["eci_value"] = AgenticCommerceProtocol::serialize_primitive(@eci_value) if @eci_value
+      out["checks_performed"] = @checks_performed.map { |v| v.serialize } if @checks_performed
+      out["iin"] = AgenticCommerceProtocol::serialize_primitive(@iin) if @iin
+      if @display_card_funding_type
+        out["display_card_funding_type"] = AgenticCommerceProtocol::serialize_schema_ref(@display_card_funding_type)
+      end
+
+      if @display_wallet_type
+        out["display_wallet_type"] = AgenticCommerceProtocol::serialize_primitive(@display_wallet_type)
+      end
+
+      out["display_brand"] = AgenticCommerceProtocol::serialize_primitive(@display_brand) if @display_brand
+      out["display_last4"] = AgenticCommerceProtocol::serialize_primitive(@display_last4) if @display_last4
+      out["metadata"] = AgenticCommerceProtocol::serialize_primitive(@metadata) if @metadata
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/agentic_commerce_protocol/models/payment_method_type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# This file is @generated
+module AgenticCommerceProtocol
+  class PaymentMethodType
+    CARD = "card".freeze
+
+    def self.all_vars
+      @all_vars ||= [CARD].freeze
+    end
+
+    def initialize(value)
+      unless PaymentMethodType.all_vars.include?(value)
+        raise "Invalid ENUM value '#{value}' for class #PaymentMethodType"
+      end
+
+      @value = value
+    end
+
+    def self.deserialize(value)
+      return value if PaymentMethodType.all_vars.include?(value)
+      raise "Invalid ENUM value '#{value}' for class #PaymentMethodType"
+    end
+
+    def serialize
+      @value
+    end
+  end
+end

data/lib/agentic_commerce_protocol/models/payment_provider.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module AgenticCommerceProtocol
+  class PaymentProvider
+    attr_accessor :provider
+    attr_accessor :supported_payment_methods
+
+    ALL_FIELD ||= ["provider", "supported_payment_methods"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `AgenticCommerceProtocol::PaymentProvider` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of AgenticCommerceProtocol::PaymentProvider")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["provider"] = AgenticCommerceProtocol::PaymentProviderType.deserialize(attributes["provider"])
+      attrs["supported_payment_methods"] = attributes["supported_payment_methods"].map { |v|
+        AgenticCommerceProtocol::PaymentMethodType.deserialize(v)
+      }
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["provider"] = AgenticCommerceProtocol::serialize_schema_ref(@provider) if @provider
+      if @supported_payment_methods
+        out["supported_payment_methods"] = @supported_payment_methods.map { |v| v.serialize }
+      end
+
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end