trycourier 2.0.0 → 3.0.0.pre.beta1

data/lib/trycourier/users/tokens/client.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require_relative "../../../requests"
+require_relative "types/user_token"
+require_relative "types/patch_user_token_opts"
+require_relative "types/get_user_token_response"
+require_relative "types/get_all_tokens_response"
+require "async"
+
+module Courier
+  module Users
+    class TokensClient
+      attr_reader :request_client
+
+      # @param request_client [RequestClient]
+      # @return [Users::TokensClient]
+      def initialize(request_client:)
+        # @type [RequestClient]
+        @request_client = request_client
+      end
+
+      # Adds multiple tokens to a user and overwrites matching existing tokens.
+      #
+      # @param user_id [String] The user's ID. This can be any uniquely identifiable string.
+      # @param request_options [RequestOptions]
+      # @return [Void]
+      def add_multiple(user_id:, request_options: nil)
+        @request_client.conn.put("/users/#{user_id}/tokens") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          unless request_options&.authorization_token.nil?
+            req.headers["Authorization"] =
+              request_options.authorization_token
+          end
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+        end
+      end
+
+      # Adds a single token to a user and overwrites a matching existing token.
+      #
+      # @param user_id [String] The user's ID. This can be any uniquely identifiable string.
+      # @param token [String] The full token string.
+      # @param request [Hash] Request of type Users::Tokens::UserToken, as a Hash
+      #   * :token (String)
+      #   * :provider_key (Users::Tokens::ProviderKey)
+      #   * :expiry_date (Hash)
+      #   * :properties (Object)
+      #   * :device (Hash)
+      #     * :app_id (String)
+      #     * :ad_id (String)
+      #     * :device_id (String)
+      #     * :platform (String)
+      #     * :manufacturer (String)
+      #     * :model (String)
+      #   * :tracking (Hash)
+      #     * :os_version (String)
+      #     * :ip (String)
+      #     * :lat (String)
+      #     * :long (String)
+      # @param request_options [RequestOptions]
+      # @return [Void]
+      def add(user_id:, token:, request:, request_options: nil)
+        @request_client.conn.put("/users/#{user_id}/tokens/#{token}") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          unless request_options&.authorization_token.nil?
+            req.headers["Authorization"] =
+              request_options.authorization_token
+          end
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+        end
+      end
+
+      # Apply a JSON Patch (RFC 6902) to the specified token.
+      #
+      # @param user_id [String] The user's ID. This can be any uniquely identifiable string.
+      # @param token [String] The full token string.
+      # @param request [Hash] Request of type Users::Tokens::PatchUserTokenOpts, as a Hash
+      #   * :patch (Array<Users::Tokens::PatchOperation>)
+      # @param request_options [RequestOptions]
+      # @return [Void]
+      def update(user_id:, token:, request:, request_options: nil)
+        @request_client.conn.patch("/users/#{user_id}/tokens/#{token}") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          unless request_options&.authorization_token.nil?
+            req.headers["Authorization"] =
+              request_options.authorization_token
+          end
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+        end
+      end
+
+      # Get single token available for a `:token`
+      #
+      # @param user_id [String] The user's ID. This can be any uniquely identifiable string.
+      # @param token [String] The full token string.
+      # @param request_options [RequestOptions]
+      # @return [Users::Tokens::GetUserTokenResponse]
+      def get(user_id:, token:, request_options: nil)
+        response = @request_client.conn.get("/users/#{user_id}/tokens/#{token}") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          unless request_options&.authorization_token.nil?
+            req.headers["Authorization"] =
+              request_options.authorization_token
+          end
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+        end
+        Users::Tokens::GetUserTokenResponse.from_json(json_object: response.body)
+      end
+
+      # Gets all tokens available for a :user_id
+      #
+      # @param user_id [String] The user's ID. This can be any uniquely identifiable string.
+      # @param request_options [RequestOptions]
+      # @return [Users::Tokens::GET_ALL_TOKENS_RESPONSE]
+      def list(user_id:, request_options: nil)
+        response = @request_client.conn.get("/users/#{user_id}/tokens") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          unless request_options&.authorization_token.nil?
+            req.headers["Authorization"] =
+              request_options.authorization_token
+          end
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+        end
+        return if response.body.nil?
+
+        response.body.map do |v|
+          v = v.to_json
+          Users::Tokens::UserToken.from_json(json_object: v)
+        end
+      end
+    end
+
+    class AsyncTokensClient
+      attr_reader :request_client
+
+      # @param request_client [AsyncRequestClient]
+      # @return [Users::AsyncTokensClient]
+      def initialize(request_client:)
+        # @type [AsyncRequestClient]
+        @request_client = request_client
+      end
+
+      # Adds multiple tokens to a user and overwrites matching existing tokens.
+      #
+      # @param user_id [String] The user's ID. This can be any uniquely identifiable string.
+      # @param request_options [RequestOptions]
+      # @return [Void]
+      def add_multiple(user_id:, request_options: nil)
+        Async do
+          @request_client.conn.put("/users/#{user_id}/tokens") do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            unless request_options&.authorization_token.nil?
+              req.headers["Authorization"] =
+                request_options.authorization_token
+            end
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          end
+        end
+      end
+
+      # Adds a single token to a user and overwrites a matching existing token.
+      #
+      # @param user_id [String] The user's ID. This can be any uniquely identifiable string.
+      # @param token [String] The full token string.
+      # @param request [Hash] Request of type Users::Tokens::UserToken, as a Hash
+      #   * :token (String)
+      #   * :provider_key (Users::Tokens::ProviderKey)
+      #   * :expiry_date (Hash)
+      #   * :properties (Object)
+      #   * :device (Hash)
+      #     * :app_id (String)
+      #     * :ad_id (String)
+      #     * :device_id (String)
+      #     * :platform (String)
+      #     * :manufacturer (String)
+      #     * :model (String)
+      #   * :tracking (Hash)
+      #     * :os_version (String)
+      #     * :ip (String)
+      #     * :lat (String)
+      #     * :long (String)
+      # @param request_options [RequestOptions]
+      # @return [Void]
+      def add(user_id:, token:, request:, request_options: nil)
+        Async do
+          @request_client.conn.put("/users/#{user_id}/tokens/#{token}") do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            unless request_options&.authorization_token.nil?
+              req.headers["Authorization"] =
+                request_options.authorization_token
+            end
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+            req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+          end
+        end
+      end
+
+      # Apply a JSON Patch (RFC 6902) to the specified token.
+      #
+      # @param user_id [String] The user's ID. This can be any uniquely identifiable string.
+      # @param token [String] The full token string.
+      # @param request [Hash] Request of type Users::Tokens::PatchUserTokenOpts, as a Hash
+      #   * :patch (Array<Users::Tokens::PatchOperation>)
+      # @param request_options [RequestOptions]
+      # @return [Void]
+      def update(user_id:, token:, request:, request_options: nil)
+        Async do
+          @request_client.conn.patch("/users/#{user_id}/tokens/#{token}") do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            unless request_options&.authorization_token.nil?
+              req.headers["Authorization"] =
+                request_options.authorization_token
+            end
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+            req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+          end
+        end
+      end
+
+      # Get single token available for a `:token`
+      #
+      # @param user_id [String] The user's ID. This can be any uniquely identifiable string.
+      # @param token [String] The full token string.
+      # @param request_options [RequestOptions]
+      # @return [Users::Tokens::GetUserTokenResponse]
+      def get(user_id:, token:, request_options: nil)
+        Async do
+          response = @request_client.conn.get("/users/#{user_id}/tokens/#{token}") do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            unless request_options&.authorization_token.nil?
+              req.headers["Authorization"] =
+                request_options.authorization_token
+            end
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          end
+          Users::Tokens::GetUserTokenResponse.from_json(json_object: response.body)
+        end
+      end
+
+      # Gets all tokens available for a :user_id
+      #
+      # @param user_id [String] The user's ID. This can be any uniquely identifiable string.
+      # @param request_options [RequestOptions]
+      # @return [Users::Tokens::GET_ALL_TOKENS_RESPONSE]
+      def list(user_id:, request_options: nil)
+        Async do
+          response = @request_client.conn.get("/users/#{user_id}/tokens") do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            unless request_options&.authorization_token.nil?
+              req.headers["Authorization"] =
+                request_options.authorization_token
+            end
+            req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          end
+          response.body&.map do |v|
+            v = v.to_json
+            Users::Tokens::UserToken.from_json(json_object: v)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trycourier/users/tokens/types/delete_user_token_opts.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class DeleteUserTokenOpts
+        attr_reader :user_id, :token, :additional_properties
+
+        # @param user_id [String]
+        # @param token [String]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Users::Tokens::DeleteUserTokenOpts]
+        def initialize(user_id:, token:, additional_properties: nil)
+          # @type [String]
+          @user_id = user_id
+          # @type [String]
+          @token = token
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of DeleteUserTokenOpts
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::DeleteUserTokenOpts]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          JSON.parse(json_object)
+          user_id = struct.user_id
+          token = struct.token
+          new(user_id: user_id, token: token, additional_properties: struct)
+        end
+
+        # Serialize an instance of DeleteUserTokenOpts to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "user_id": @user_id, "token": @token }.to_json
+        end
+
+        # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+        #
+        # @param obj [Object]
+        # @return [Void]
+        def self.validate_raw(obj:)
+          obj.user_id.is_a?(String) != false || raise("Passed value for field obj.user_id is not the expected type, validation failed.")
+          obj.token.is_a?(String) != false || raise("Passed value for field obj.token is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

data/lib/trycourier/users/tokens/types/device.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class Device
+        attr_reader :app_id, :ad_id, :device_id, :platform, :manufacturer, :model, :additional_properties
+
+        # @param app_id [String] Id of the application the token is used for
+        # @param ad_id [String] Id of the advertising identifier
+        # @param device_id [String] Id of the device the token is associated with
+        # @param platform [String] The device platform i.e. android, ios, web
+        # @param manufacturer [String] The device manufacturer
+        # @param model [String] The device model
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Users::Tokens::Device]
+        def initialize(app_id: nil, ad_id: nil, device_id: nil, platform: nil, manufacturer: nil, model: nil,
+                       additional_properties: nil)
+          # @type [String] Id of the application the token is used for
+          @app_id = app_id
+          # @type [String] Id of the advertising identifier
+          @ad_id = ad_id
+          # @type [String] Id of the device the token is associated with
+          @device_id = device_id
+          # @type [String] The device platform i.e. android, ios, web
+          @platform = platform
+          # @type [String] The device manufacturer
+          @manufacturer = manufacturer
+          # @type [String] The device model
+          @model = model
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of Device
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::Device]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          JSON.parse(json_object)
+          app_id = struct.app_id
+          ad_id = struct.ad_id
+          device_id = struct.device_id
+          platform = struct.platform
+          manufacturer = struct.manufacturer
+          model = struct.model
+          new(app_id: app_id, ad_id: ad_id, device_id: device_id, platform: platform, manufacturer: manufacturer,
+              model: model, additional_properties: struct)
+        end
+
+        # Serialize an instance of Device to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          {
+            "app_id": @app_id,
+            "ad_id": @ad_id,
+            "device_id": @device_id,
+            "platform": @platform,
+            "manufacturer": @manufacturer,
+            "model": @model
+          }.to_json
+        end
+
+        # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+        #
+        # @param obj [Object]
+        # @return [Void]
+        def self.validate_raw(obj:)
+          obj.app_id&.is_a?(String) != false || raise("Passed value for field obj.app_id is not the expected type, validation failed.")
+          obj.ad_id&.is_a?(String) != false || raise("Passed value for field obj.ad_id is not the expected type, validation failed.")
+          obj.device_id&.is_a?(String) != false || raise("Passed value for field obj.device_id is not the expected type, validation failed.")
+          obj.platform&.is_a?(String) != false || raise("Passed value for field obj.platform is not the expected type, validation failed.")
+          obj.manufacturer&.is_a?(String) != false || raise("Passed value for field obj.manufacturer is not the expected type, validation failed.")
+          obj.model&.is_a?(String) != false || raise("Passed value for field obj.model is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

data/lib/trycourier/users/tokens/types/expiry_date.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class ExpiryDate
+        # Deserialize a JSON object to an instance of ExpiryDate
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::ExpiryDate]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          begin
+            struct.is_a?(String) != false || raise("Passed value for field struct is not the expected type, validation failed.")
+            return json_object
+          rescue StandardError
+            # noop
+          end
+          begin
+            struct.is_a?(Boolean) != false || raise("Passed value for field struct is not the expected type, validation failed.")
+            return json_object
+          rescue StandardError
+            # noop
+          end
+          struct
+        end
+
+        # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+        #
+        # @param obj [Object]
+        # @return [Void]
+        def self.validate_raw(obj:)
+          begin
+            return obj.is_a?(String) != false || raise("Passed value for field obj is not the expected type, validation failed.")
+          rescue StandardError
+            # noop
+          end
+          begin
+            return obj.is_a?(Boolean) != false || raise("Passed value for field obj is not the expected type, validation failed.")
+          rescue StandardError
+            # noop
+          end
+          raise("Passed value matched no type within the union, validation failed.")
+        end
+      end
+    end
+  end
+end

data/lib/trycourier/users/tokens/types/get_all_tokens_response.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "user_token"
+
+module Courier
+  module Users
+    class Tokens
+      GET_ALL_TOKENS_RESPONSE = Array
+    end
+  end
+end

data/lib/trycourier/users/tokens/types/get_user_token_opts.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class GetUserTokenOpts
+        attr_reader :user_id, :token, :additional_properties
+
+        # @param user_id [String]
+        # @param token [String]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Users::Tokens::GetUserTokenOpts]
+        def initialize(user_id:, token:, additional_properties: nil)
+          # @type [String]
+          @user_id = user_id
+          # @type [String]
+          @token = token
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of GetUserTokenOpts
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::GetUserTokenOpts]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          JSON.parse(json_object)
+          user_id = struct.user_id
+          token = struct.token
+          new(user_id: user_id, token: token, additional_properties: struct)
+        end
+
+        # Serialize an instance of GetUserTokenOpts to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "user_id": @user_id, "token": @token }.to_json
+        end
+
+        # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+        #
+        # @param obj [Object]
+        # @return [Void]
+        def self.validate_raw(obj:)
+          obj.user_id.is_a?(String) != false || raise("Passed value for field obj.user_id is not the expected type, validation failed.")
+          obj.token.is_a?(String) != false || raise("Passed value for field obj.token is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

data/lib/trycourier/users/tokens/types/get_user_token_response.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "token_status"
+require_relative "provider_key"
+require_relative "expiry_date"
+require_relative "device"
+require_relative "tracking"
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class GetUserTokenResponse
+        attr_reader :status, :status_reason, :token, :provider_key, :expiry_date, :properties, :device, :tracking,
+                    :additional_properties
+
+        # @param status [Users::Tokens::TokenStatus]
+        # @param status_reason [String] The reason for the token status.
+        # @param token [String] Full body of the token. Must match token in URL.
+        # @param provider_key [Users::Tokens::ProviderKey]
+        # @param expiry_date [Users::Tokens::ExpiryDate] ISO 8601 formatted date the token expires. Defaults to 2 months. Set to false to disable expiration.
+        # @param properties [Object] Properties sent to the provider along with the token
+        # @param device [Users::Tokens::Device] Information about the device the token is associated with.
+        # @param tracking [Users::Tokens::Tracking] Information about the device the token is associated with.
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Users::Tokens::GetUserTokenResponse]
+        def initialize(provider_key:, status: nil, status_reason: nil, token: nil, expiry_date: nil, properties: nil,
+                       device: nil, tracking: nil, additional_properties: nil)
+          # @type [Users::Tokens::TokenStatus]
+          @status = status
+          # @type [String] The reason for the token status.
+          @status_reason = status_reason
+          # @type [String] Full body of the token. Must match token in URL.
+          @token = token
+          # @type [Users::Tokens::ProviderKey]
+          @provider_key = provider_key
+          # @type [Users::Tokens::ExpiryDate] ISO 8601 formatted date the token expires. Defaults to 2 months. Set to false to disable expiration.
+          @expiry_date = expiry_date
+          # @type [Object] Properties sent to the provider along with the token
+          @properties = properties
+          # @type [Users::Tokens::Device] Information about the device the token is associated with.
+          @device = device
+          # @type [Users::Tokens::Tracking] Information about the device the token is associated with.
+          @tracking = tracking
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of GetUserTokenResponse
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::GetUserTokenResponse]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          parsed_json = JSON.parse(json_object)
+          status = struct.status
+          status_reason = struct.status_reason
+          token = struct.token
+          provider_key = struct.provider_key
+          if parsed_json["expiry_date"].nil?
+            expiry_date = nil
+          else
+            expiry_date = parsed_json["expiry_date"].to_json
+            expiry_date = Users::Tokens::ExpiryDate.from_json(json_object: expiry_date)
+          end
+          properties = struct.properties
+          if parsed_json["device"].nil?
+            device = nil
+          else
+            device = parsed_json["device"].to_json
+            device = Users::Tokens::Device.from_json(json_object: device)
+          end
+          if parsed_json["tracking"].nil?
+            tracking = nil
+          else
+            tracking = parsed_json["tracking"].to_json
+            tracking = Users::Tokens::Tracking.from_json(json_object: tracking)
+          end
+          new(status: status, status_reason: status_reason, token: token, provider_key: provider_key,
+              expiry_date: expiry_date, properties: properties, device: device, tracking: tracking, additional_properties: struct)
+        end
+
+        # Serialize an instance of GetUserTokenResponse to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          {
+            "status": @status,
+            "status_reason": @status_reason,
+            "token": @token,
+            "provider_key": @provider_key,
+            "expiry_date": @expiry_date,
+            "properties": @properties,
+            "device": @device,
+            "tracking": @tracking
+          }.to_json
+        end
+
+        # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+        #
+        # @param obj [Object]
+        # @return [Void]
+        def self.validate_raw(obj:)
+          obj.status&.is_a?(Users::Tokens::TokenStatus) != false || raise("Passed value for field obj.status is not the expected type, validation failed.")
+          obj.status_reason&.is_a?(String) != false || raise("Passed value for field obj.status_reason is not the expected type, validation failed.")
+          obj.token&.is_a?(String) != false || raise("Passed value for field obj.token is not the expected type, validation failed.")
+          obj.provider_key.is_a?(Users::Tokens::ProviderKey) != false || raise("Passed value for field obj.provider_key is not the expected type, validation failed.")
+          obj.expiry_date.nil? || Users::Tokens::ExpiryDate.validate_raw(obj: obj.expiry_date)
+          obj.properties&.is_a?(Object) != false || raise("Passed value for field obj.properties is not the expected type, validation failed.")
+          obj.device.nil? || Users::Tokens::Device.validate_raw(obj: obj.device)
+          obj.tracking.nil? || Users::Tokens::Tracking.validate_raw(obj: obj.tracking)
+        end
+      end
+    end
+  end
+end