lingara 0.1.0.pre.alpha.13 → 0.2.0.pre.alpha.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c106647ff775f7a271c4ad22e324eda04a23f239088cd6e88b9ef039c467de3
-  data.tar.gz: 9e8a5830acde513c26696500d902e182d14790b37ce7107853caa15e72c1cbe5
+  metadata.gz: 1cfd533625ec4e78a0e68f5327ce5f3af893e26f4e04ab4c25b1e8f2bbdf2e41
+  data.tar.gz: 435203b71ac2e9856463fead5cf5c91e852e2ba92b4d9bf1f9b3322609d05791
 SHA512:
-  metadata.gz: c7e19be3b61b6cd9df78caf67b3591af23d404b22bd7f960679c4a4800e18d40303ef0b2860fc09d6824530e81f64287cf31c970b8381dd73a137631a0e7e4c8
-  data.tar.gz: cf52f86493fbd3d8065b07057b60be6426f59118cb253cf0c37e3e1e8494d1ac992d4cb1f46615598958f55d5a6e4f643b0718d71a1aa8c667735f4f75c33737
+  metadata.gz: 3265f0f31df57f75f58f2c0b2465d40ff3770b54c979adaf2d64268a929db753d30125294a78df5f678d616c619e2b854052cb10f66dad0e7ef91b379c3dbd43
+  data.tar.gz: c9db5cd1433951e938fdcf2b6aa4bc6564e4abb2d6a386890def4acb96fc8a0396bc9144cccf363bf724f2914fcfc3b445003a86602ef21a7749eeb81b3efa6d

data/README.md

@@ -61,7 +61,7 @@ calls them. A client without credentials sends the other nine without
 
 ## Streams
 
-The four streaming methods take a block, or return a stream:
+The streaming methods take a block, or return a stream:
 
 - **With a block**, the call sends the request, yields each event and returns
   a `Lingara::StreamResult` (`#served_version`). `break`, `return` or `throw`
@@ -157,6 +157,77 @@ for another event returns the **first** answer. Only
 Event `data` is rendered at your client's pinned version, and this library's
 models are those of `Lingara::GENERATED_FOR_VERSION`: pin your client to it.
 
+## Embedding Lingara
+
+A game or website that puts Lingara in front of its players vouches for each
+player from its own server.
+
+**Mint on your server, never on a player's device**, from a **metered**
+client holding `embed:mint` (with an explicit `scopes:`, include it):
+
+```ruby
+minted = client.create_embed_token(player_ref: "guild-42/player-1001", scopes: ["embed:play"]).value
+minted.subject              # "lgr_sub_…": store it beside the player
+minted.token.expose_secret  # "lgr_et_…": hand it, with minted.expires_at, to the player kit
+```
+
+`player_ref` is your own reference for the player (at most 128 bytes). It is
+sent as one path segment wherever it appears, so `/`, spaces and non-ASCII
+text are safe. The result is a `Lingara::MintedToken`, and its `token` renders
+`[REDACTED]` in `inspect`, `to_s` and `pp` like every other token here. Store
+`subject`: it is how every event and webhook names that player. The token
+lives 900 s and Lingara never refreshes it, so mint again when the player kit
+asks. `expires_in` (whole seconds) is there for a device whose clock cannot be
+trusted. An allowance client is refused with `403 embed_needs_metered`.
+
+`client.delete_embed_player(player_ref)` deletes a player and revokes its
+tokens. It returns a `Lingara::Response` whose `value` is `nil`. It is
+idempotent, since an unknown player is a success too, and it keeps working
+while embedding is switched off for your client.
+
+`client.link_embed_player(player_ref)` links a player to the Lingara account
+that granted your app access (`embed:play`); its `value` is an
+`EmbedPlayerLink`. Call it on a client whose `token_source:` returns the
+**player's delegated token** — the one your server received from that
+account's own consent — never on your client-credentials client, which gets
+`403 embed_link_needs_grant`. The library does not obtain that token yet; the
+`link_embed_player` snippet's `delegated_client` builds the client in a few
+lines. A fixed token is retried once on a `401`, so a revoked grant surfaces
+as a `Lingara::ApiError` with status 401. `"existing"` is a success too, and a
+repeat moves what could not move before: call again while
+`kept["lesson_plans"]` is non-zero.
+
+`client.unlink_embed_player(player_ref)` ends that link (`embed:mint`, your
+ordinary client); its `value` is `nil`. A `404 embed_link_not_found` after a
+retried call means it was already unlinked.
+
+`client.send_dialogue_turn(npc:, source_lang:, target_lang:, level:, line:, history:)`
+streams one NPC reply (`embed:play`, from an embed token or a metered
+client's own token) as `delta` and `notice` events, ending on `done`. The
+window is yours to keep, and the schema bounds it: at most 12 `history`
+entries, with `line` and each entry at most 500 characters. Send an NPC reply
+back into `history` cut to its first 500 characters. A turn is **never
+retried**, because each attempt spends the player's NPC cells and the payer's:
+a `429` or `503` raises `Lingara::ApiError` at once with its `retry_after`,
+and you decide whether to send the turn again. No retry helps
+`403 embed_needs_metered` or `422 safety_input_flagged` (say something else).
+
+`practice.completed` arrives typed as `Lingara::Events::PracticeCompleted` on
+the feed, the tail and webhooks, and your client needs `events:read` and
+`embed:play` to hear it. A game reports practice with
+`Lingara::Events::InboundEvent.world_practice_completed(…)`, which needs
+`events:write` and `embed:play`.
+
+A player-side caller uses an embed token through a custom `token_source:`
+whose `#token` returns `Lingara::AccessToken.new(lgr_et_token)`: no client
+secret is involved. The library never sends `X-Lingara-Embed-Origin`, so a
+token minted with `origin:` belongs to the browser widget, and a game mints
+without one.
+
+For higher-level helpers on your server, see the
+[Lingara embed server kits](https://github.com/Spinning-Cat-Studios/lingara_embeddable_sdk)
+(the `lingara-embed` gem).
+
 ## Errors
 
 Every failure is a `Lingara::Error`, one of four:
@@ -169,7 +240,8 @@ Every failure is a `Lingara::Error`, one of four:
 | `Lingara::TransportError` | no usable answer | `kind`: `:connect`, `:tls`, `:reset`, `:timeout`, `:stream_ended_early`, `:malformed_response`, `:malformed_event` |
 
 A `429` or `503` with a `Retry-After` of at most `retry_after_cap:` (60 s) is
-retried, up to `max_attempts:` (3) tries; a `401` fetches a fresh token and
+retried, up to `max_attempts:` (3) tries, except by `send_dialogue_turn`,
+which sends once; a `401` fetches a fresh token and
 retries once. A stream that has yielded an event is never replayed. Your own
 interrupt (`Thread#raise`, `Thread#kill`, `Timeout.timeout`) is never wrapped
 and never retried.

data/lib/lingara/client.rb

@@ -49,7 +49,7 @@ module Lingara
       ))
     end
 
-    # ── The thirteen operations, over operations.rb ───────────────────────
+    # ── The operations, over operations.rb ────────────────────────────────
 
     # Streams a vocabulary list (scope vocab:generate).
     def generate_vocabulary(**body, &block)
@@ -158,6 +158,57 @@ module Lingara
       json("sendEvent", [], body: JSON.generate(event.to_hash), headers: {"Idempotency-Key" => key})
     end
 
+    # ── Embedding (ADR 1.10.26w) ──────────────────────────────────────────
+
+    # Mints a player's embed token (scope embed:mint, a metered client
+    # only): player_ref:, and optionally scopes: (a list) and origin:. Call
+    # it on your server, never on a player's device. Returns a MintedToken,
+    # whose token renders [REDACTED]. The token lives 900 s and is never
+    # refreshed: mint again when the player kit asks.
+    def create_embed_token(**body)
+      operation = OPERATIONS.fetch("createEmbedToken")
+      json("createEmbedToken", [], body: payload(operation, body), decode: MintedToken.method(:decode))
+    end
+
+    # Deletes a player and revokes its tokens (scope embed:mint). An unknown
+    # player_ref is a success too, so a retry is safe, and it works while
+    # embedding is switched off. Returns a Response whose value is nil.
+    def delete_embed_player(player_ref)
+      no_content("deleteEmbedPlayer", [player_ref])
+    end
+
+    # Links a player to the Lingara account that granted your app access
+    # (scope embed:play; ADR 22.10.26t). Call it on a client whose
+    # token_source: returns the player's delegated token, from that account's
+    # own consent: a client-credentials client is refused 403
+    # embed_link_needs_grant. The library does not obtain that token yet. A
+    # repeat answers "existing" and moves what could not move before, so a
+    # retry is safe: call again while kept["lesson_plans"] is non-zero.
+    # Returns a Response whose value is an EmbedPlayerLink.
+    def link_embed_player(player_ref)
+      json("linkEmbedPlayer", [player_ref])
+    end
+
+    # Ends a player's link (scope embed:mint, on your ordinary client). No
+    # live link is 404 embed_link_not_found, which after a retried success
+    # means it was already unlinked. Returns a Response whose value is nil.
+    def unlink_embed_player(player_ref)
+      no_content("unlinkEmbedPlayer", [player_ref])
+    end
+
+    # Streams an NPC's reply to one line (scope embed:play, from an embed
+    # token or a metered client's own token): delta and notice events, ending
+    # on done. Each turn spends the player's NPC cells and the payer's, so it
+    # is sent once, never retried: a 429 or 503 raises ApiError at once,
+    # retry_after included, and the caller decides whether to send again.
+    # The window is the schema's: at most 12 history entries, line and each
+    # entry at most 500 characters; send an NPC reply back cut to its first
+    # 500. 403 embed_needs_metered and 422 safety_input_flagged (say
+    # something else) are refusals no retry helps.
+    def send_dialogue_turn(**body, &block)
+      stream("sendDialogueTurn", [], body, policy: @tail_policy, &block)
+    end
+
     def to_s
       inspect
     end
@@ -179,16 +230,34 @@ module Lingara
       raise ArgumentError, "stream_idle_timeout: must be a positive number" unless idle.is_a?(Numeric) && idle.positive?
     end
 
-    # +body+ is JSON text already; +headers+ join every attempt's.
-    def json(id, args, query: nil, body: nil, headers: {})
+    # +body+ is JSON text already; +headers+ join every attempt's. +decode+
+    # replaces the generated model's decoding (create_embed_token's).
+    def json(id, args, query: nil, body: nil, headers: {}, decode: nil)
       operation = OPERATIONS.fetch(id)
       url = url_for(operation, args, query)
+      decode ||= ->(text) { Decoding.response(operation[:response], text) }
       pipeline(operation, url, body, headers: headers) do |response, _phase, observe|
         served = observe.call(response)
-        Response.new(value: Decoding.response(operation[:response], response.body.to_s), served_version: served)
+        Response.new(value: decode.call(response.body.to_s), served_version: served)
+      end
+    end
+
+    # An operation whose success has no body (D4): no request body and no
+    # Content-Type, and any 2xx body is discarded unread. Called by name: a
+    # route's `response: nil` already means "a plain Hash".
+    def no_content(id, args)
+      operation = OPERATIONS.fetch(id)
+      pipeline(operation, url_for(operation, args), nil) do |response, _phase, observe|
+        Response.new(value: nil, served_version: observe.call(response))
       end
     end
 
+    # The request model's constructor refuses a bad keyword before any
+    # request is sent: a programming error, like Client.new's.
+    def payload(operation, body)
+      body && JSON.generate(Lingara.const_get(operation[:request_body]).new(body).to_hash)
+    end
+
     # One page of the feed as its raw Hash, so each item reaches
     # Events.decode as the bytes the server sent (D6).
     def page(operation, url)
@@ -198,14 +267,13 @@ module Lingara
       end
     end
 
-    def stream(id, args, body, query: nil, headers: {}, &block)
+    # +policy+ is the single-attempt one for a stream that must not be
+    # retried (send_dialogue_turn).
+    def stream(id, args, body, query: nil, headers: {}, policy: @policy, &block)
       operation = OPERATIONS.fetch(id)
       url = url_for(operation, args, query)
-      # The request model's constructor refuses a bad keyword before any
-      # request is sent: a programming error, like Client.new's.
-      payload = body && JSON.generate(Lingara.const_get(operation[:request_body]).new(body).to_hash)
-      send = ->(*call, **options, &consume) { pipeline(*call, headers: headers, **options, &consume) }
-      events = EventStream.new(pipeline: send, operation: operation, url: url, body: payload)
+      send = ->(*call, **options, &consume) { pipeline(*call, headers: headers, policy: policy, **options, &consume) }
+      events = EventStream.new(pipeline: send, operation: operation, url: url, body: payload(operation, body))
       block ? events.run(&block) : events
     end
 

data/lib/lingara/events/catalogue.rb

@@ -30,6 +30,15 @@ module Lingara
     # app.uninstalled: data is a Lingara::AppUninstalledData.
     AppUninstalled = Data.define(*ENVELOPE) { include Event }
 
+    # app.disabled: data is a Lingara::AppDisabledData.
+    AppDisabled = Data.define(*ENVELOPE) { include Event }
+
+    # app.enabled: data is a Lingara::AppEnabledData.
+    AppEnabled = Data.define(*ENVELOPE) { include Event }
+
+    # practice.completed: data is a Lingara::PracticeCompletedData.
+    PracticeCompleted = Data.define(*ENVELOPE) { include Event }
+
     # An event of a type this library does not know: data is the raw JSON
     # object, as a Hash. The catalogue only grows, so acknowledge it.
     UnknownEvent = Data.define(*ENVELOPE) { include Event }
@@ -42,7 +51,10 @@ module Lingara
         "usage.threshold_reached" => [UsageThresholdReached, "UsageThresholdReachedData"].freeze,
         "webhook.test" => [WebhookTest, nil].freeze,
         "app.installed" => [AppInstalled, "AppInstalledData"].freeze,
-        "app.uninstalled" => [AppUninstalled, "AppUninstalledData"].freeze
+        "app.uninstalled" => [AppUninstalled, "AppUninstalledData"].freeze,
+        "app.disabled" => [AppDisabled, "AppDisabledData"].freeze,
+        "app.enabled" => [AppEnabled, "AppEnabledData"].freeze,
+        "practice.completed" => [PracticeCompleted, "PracticeCompletedData"].freeze
       }.freeze
     end
 
@@ -53,7 +65,8 @@ module Lingara
       # Each inbound type's constructor.
       CONSTRUCTORS = {
         "world.context_changed" => :world_context_changed,
-        "world.practice_requested" => :world_practice_requested
+        "world.practice_requested" => :world_practice_requested,
+        "world.practice_completed" => :world_practice_completed
       }.freeze
 
       attr_reader :type, :data
@@ -70,6 +83,11 @@ module Lingara
         new("world.practice_requested", data.is_a?(Lingara::WorldPracticeRequested) ? data : Lingara::WorldPracticeRequested.new(data))
       end
 
+      # world.practice_completed, from a Lingara::WorldPracticeCompleted or the Hash one is built from.
+      def self.world_practice_completed(data)
+        new("world.practice_completed", data.is_a?(Lingara::WorldPracticeCompleted) ? data : Lingara::WorldPracticeCompleted.new(data))
+      end
+
       def initialize(type, data)
         @type = type
         @data = data

data/lib/lingara/minted_token.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lingara
+  # What create_embed_token returns (ADR 1.10.26w D3): a player's embed
+  # token and the five fields minted beside it. #token is an AccessToken, so
+  # the lgr_et_ value renders [REDACTED] in #inspect, #to_s and pp like
+  # every other token (K1); token.expose_secret reads it.
+  #
+  # Lives at lingara/minted_token, never lingara/embed: that require path is
+  # the lingara-embed gem's, and two gems shipping one path shadow each other
+  # on $LOAD_PATH.
+  class MintedToken
+    include Redacted
+
+    PREFIX = "lgr_et_"
+    # Each answer field and the JSON type it must have.
+    FIELDS = {
+      "token" => String, "expires_at" => String, "expires_in" => Integer, "subject" => String, "scopes" => Array,
+      "account_linked" => [true, false]
+    }.freeze
+
+    # +token+ an AccessToken; +expires_at+ a Time, as the generated
+    # EmbedToken reads it; +expires_in+ whole seconds, for a device whose
+    # clock cannot be trusted; +subject+ the player's lgr_sub_, stable across
+    # mints; +scopes+ as granted; +account_linked+ always false until a
+    # player links an account.
+    attr_reader :token, :expires_at, :expires_in, :subject, :scopes, :account_linked
+
+    # A mint's answer body to a MintedToken. Every field must be present and
+    # of its JSON type, and the token must start lgr_et_; anything else is
+    # TransportError(:malformed_response), raised with no cause so nothing
+    # of the body, the token included, travels with it.
+    def self.decode(body)
+      fields = JSON.parse(body)
+      raise ArgumentError unless well_typed?(fields)
+      model = EmbedToken.build_from_hash(fields)
+      new(token: AccessToken.new(model.token), expires_at: model.expires_at, expires_in: model.expires_in,
+        subject: model.subject, scopes: model.scopes, account_linked: model.account_linked)
+    rescue
+      raise TransportError.new(:malformed_response, "the answer is not a minted token"), cause: nil
+    end
+
+    def self.well_typed?(fields)
+      return false unless fields.is_a?(Hash)
+      typed = FIELDS.all? do |name, type|
+        type.is_a?(Array) ? type.include?(fields[name]) : fields[name].is_a?(type)
+      end
+      typed && fields["token"].start_with?(PREFIX) && fields["scopes"].all?(String)
+    end
+    private_class_method :well_typed?
+
+    def initialize(token:, expires_at:, expires_in:, subject:, scopes:, account_linked:)
+      @token = token
+      @expires_at = expires_at
+      @expires_in = expires_in
+      @subject = subject.dup.freeze
+      @scopes = scopes.map { |scope| scope.dup.freeze }.freeze
+      @account_linked = account_linked
+      freeze
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "#<Lingara::MintedToken token=#{REDACTED} expires_at=#{@expires_at.inspect} expires_in=#{@expires_in} " \
+        "subject=#{@subject.inspect} scopes=#{@scopes.inspect} account_linked=#{@account_linked}>"
+    end
+  end
+end

data/lib/lingara/models/allowance_row.rb

@@ -3,7 +3,7 @@
 
 #Generate vocabulary lists and lesson plans, and hold tutor conversations, in the languages Lingara teaches. Each call is paid for by the client that makes it: an `allowance` client spends its owner's allowance, and a `metered` client is billed for its usage.
 
-The version of the OpenAPI document: 2026-10-affable-towhee
+The version of the OpenAPI document: 2026-10-virile-dragon
 
 Generated by: https://openapi-generator.tech
 Generator version: 7.14.0

data/lib/lingara/models/app_context_slice.rb

@@ -3,7 +3,7 @@
 
 #Generate vocabulary lists and lesson plans, and hold tutor conversations, in the languages Lingara teaches. Each call is paid for by the client that makes it: an `allowance` client spends its owner's allowance, and a `metered` client is billed for its usage.
 
-The version of the OpenAPI document: 2026-10-affable-towhee
+The version of the OpenAPI document: 2026-10-virile-dragon
 
 Generated by: https://openapi-generator.tech
 Generator version: 7.14.0

data/lib/lingara/models/app_disabled_data.rb

@@ -0,0 +1,263 @@
+=begin
+#Lingara API
+
+#Generate vocabulary lists and lesson plans, and hold tutor conversations, in the languages Lingara teaches. Each call is paid for by the client that makes it: an `allowance` client spends its owner's allowance, and a `metered` client is billed for its usage.
+
+The version of the OpenAPI document: 2026-10-virile-dragon
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.14.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Lingara
+  class AppDisabledData
+    attr_accessor :client_id
+
+    attr_accessor :install_id
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'client_id' => :'client_id',
+        :'install_id' => :'install_id'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'client_id' => :'String',
+        :'install_id' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Lingara::AppDisabledData` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Lingara::AppDisabledData`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'client_id')
+        self.client_id = attributes[:'client_id']
+      else
+        self.client_id = nil
+      end
+
+      if attributes.key?(:'install_id')
+        self.install_id = attributes[:'install_id']
+      else
+        self.install_id = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @client_id.nil?
+        invalid_properties.push('invalid value for "client_id", client_id cannot be nil.')
+      end
+
+      if @install_id.nil?
+        invalid_properties.push('invalid value for "install_id", install_id cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @client_id.nil?
+      return false if @install_id.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] client_id Value to be assigned
+    def client_id=(client_id)
+      if client_id.nil?
+        fail ArgumentError, 'client_id cannot be nil'
+      end
+
+      @client_id = client_id
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] install_id Value to be assigned
+    def install_id=(install_id)
+      if install_id.nil?
+        fail ArgumentError, 'install_id cannot be nil'
+      end
+
+      @install_id = install_id
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          client_id == o.client_id &&
+          install_id == o.install_id
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [client_id, install_id].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = Lingara.const_get(type)
+        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end