trycourier 1.10.0 → 3.0.0.pre.beta1

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class GetUserTokensOpts
+        attr_reader :user_id, :additional_properties
+
+        # @param user_id [String]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Users::Tokens::GetUserTokensOpts]
+        def initialize(user_id:, additional_properties: nil)
+          # @type [String]
+          @user_id = user_id
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of GetUserTokensOpts
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::GetUserTokensOpts]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          JSON.parse(json_object)
+          user_id = struct.user_id
+          new(user_id: user_id, additional_properties: struct)
+        end
+
+        # Serialize an instance of GetUserTokensOpts to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "user_id": @user_id }.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.")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Courier
+  module Users
+    class Tokens
+      class PatchOp
+        REPLACE = "replace"
+        ADD = "add"
+        REMOVE = "remove"
+        COPY = "copy"
+        MOVE = "move"
+        TEST = "test"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class PatchOperation
+        attr_reader :op, :path, :value, :additional_properties
+
+        # @param op [String] The operation to perform.
+        # @param path [String] The JSON path specifying the part of the profile to operate on.
+        # @param value [String] The value for the operation.
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Users::Tokens::PatchOperation]
+        def initialize(op:, path:, value: nil, additional_properties: nil)
+          # @type [String] The operation to perform.
+          @op = op
+          # @type [String] The JSON path specifying the part of the profile to operate on.
+          @path = path
+          # @type [String] The value for the operation.
+          @value = value
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of PatchOperation
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::PatchOperation]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          JSON.parse(json_object)
+          op = struct.op
+          path = struct.path
+          value = struct.value
+          new(op: op, path: path, value: value, additional_properties: struct)
+        end
+
+        # Serialize an instance of PatchOperation to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "op": @op, "path": @path, "value": @value }.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.op.is_a?(String) != false || raise("Passed value for field obj.op is not the expected type, validation failed.")
+          obj.path.is_a?(String) != false || raise("Passed value for field obj.path is not the expected type, validation failed.")
+          obj.value&.is_a?(String) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "patch_operation"
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class PatchUserTokenOpts
+        attr_reader :patch, :additional_properties
+
+        # @param patch [Array<Users::Tokens::PatchOperation>]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Users::Tokens::PatchUserTokenOpts]
+        def initialize(patch:, additional_properties: nil)
+          # @type [Array<Users::Tokens::PatchOperation>]
+          @patch = patch
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of PatchUserTokenOpts
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::PatchUserTokenOpts]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          parsed_json = JSON.parse(json_object)
+          patch = parsed_json["patch"]&.map do |v|
+            v = v.to_json
+            Users::Tokens::PatchOperation.from_json(json_object: v)
+          end
+          new(patch: patch, additional_properties: struct)
+        end
+
+        # Serialize an instance of PatchUserTokenOpts to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "patch": @patch }.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.patch.is_a?(Array) != false || raise("Passed value for field obj.patch is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Courier
+  module Users
+    class Tokens
+      class ProviderKey
+        FIREBASE_FCM = "firebase-fcm"
+        APN = "apn"
+        EXPO = "expo"
+        ONESIGNAL = "onesignal"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "user_token"
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class PutUserTokenOpts
+        attr_reader :user_id, :token, :additional_properties
+
+        # @param user_id [String]
+        # @param token [Users::Tokens::UserToken]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Users::Tokens::PutUserTokenOpts]
+        def initialize(user_id:, token:, additional_properties: nil)
+          # @type [String]
+          @user_id = user_id
+          # @type [Users::Tokens::UserToken]
+          @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 PutUserTokenOpts
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::PutUserTokenOpts]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          parsed_json = JSON.parse(json_object)
+          user_id = struct.user_id
+          if parsed_json["token"].nil?
+            token = nil
+          else
+            token = parsed_json["token"].to_json
+            token = Users::Tokens::UserToken.from_json(json_object: token)
+          end
+          new(user_id: user_id, token: token, additional_properties: struct)
+        end
+
+        # Serialize an instance of PutUserTokenOpts 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.")
+          Users::Tokens::UserToken.validate_raw(obj: obj.token)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "user_token"
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class PutUserTokensOpts
+        attr_reader :user_id, :tokens, :additional_properties
+
+        # @param user_id [String]
+        # @param tokens [Array<Users::Tokens::UserToken>]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Users::Tokens::PutUserTokensOpts]
+        def initialize(user_id:, tokens:, additional_properties: nil)
+          # @type [String]
+          @user_id = user_id
+          # @type [Array<Users::Tokens::UserToken>]
+          @tokens = tokens
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of PutUserTokensOpts
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::PutUserTokensOpts]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          parsed_json = JSON.parse(json_object)
+          user_id = struct.user_id
+          tokens = parsed_json["tokens"]&.map do |v|
+            v = v.to_json
+            Users::Tokens::UserToken.from_json(json_object: v)
+          end
+          new(user_id: user_id, tokens: tokens, additional_properties: struct)
+        end
+
+        # Serialize an instance of PutUserTokensOpts to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "user_id": @user_id, "tokens": @tokens }.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.tokens.is_a?(Array) != false || raise("Passed value for field obj.tokens is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Courier
+  module Users
+    class Tokens
+      class TokenStatus
+        ACTIVE = "active"
+        UNKNOWN = "unknown"
+        FAILED = "failed"
+        REVOKED = "revoked"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class Tracking
+        attr_reader :os_version, :ip, :lat, :long, :additional_properties
+
+        # @param os_version [String] The operating system version
+        # @param ip [String] The IP address of the device
+        # @param lat [String] The latitude of the device
+        # @param long [String] The longitude of the device
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Users::Tokens::Tracking]
+        def initialize(os_version: nil, ip: nil, lat: nil, long: nil, additional_properties: nil)
+          # @type [String] The operating system version
+          @os_version = os_version
+          # @type [String] The IP address of the device
+          @ip = ip
+          # @type [String] The latitude of the device
+          @lat = lat
+          # @type [String] The longitude of the device
+          @long = long
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of Tracking
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::Tracking]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          JSON.parse(json_object)
+          os_version = struct.os_version
+          ip = struct.ip
+          lat = struct.lat
+          long = struct.long
+          new(os_version: os_version, ip: ip, lat: lat, long: long, additional_properties: struct)
+        end
+
+        # Serialize an instance of Tracking to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "os_version": @os_version, "ip": @ip, "lat": @lat, "long": @long }.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.os_version&.is_a?(String) != false || raise("Passed value for field obj.os_version is not the expected type, validation failed.")
+          obj.ip&.is_a?(String) != false || raise("Passed value for field obj.ip is not the expected type, validation failed.")
+          obj.lat&.is_a?(String) != false || raise("Passed value for field obj.lat is not the expected type, validation failed.")
+          obj.long&.is_a?(String) != false || raise("Passed value for field obj.long is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "provider_key"
+require_relative "expiry_date"
+require_relative "device"
+require_relative "tracking"
+require "json"
+
+module Courier
+  module Users
+    class Tokens
+      class UserToken
+        attr_reader :token, :provider_key, :expiry_date, :properties, :device, :tracking, :additional_properties
+
+        # @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::UserToken]
+        def initialize(provider_key:, token: nil, expiry_date: nil, properties: nil, device: nil, tracking: nil,
+                       additional_properties: nil)
+          # @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 UserToken
+        #
+        # @param json_object [JSON]
+        # @return [Users::Tokens::UserToken]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          parsed_json = JSON.parse(json_object)
+          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(token: token, provider_key: provider_key, expiry_date: expiry_date, properties: properties,
+              device: device, tracking: tracking, additional_properties: struct)
+        end
+
+        # Serialize an instance of UserToken to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          {
+            "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.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