celitech 2.0.7

data/lib/celitech/models/top_up_esim_request.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Celitech
+  module Models
+    class TopUpEsimRequest
+      include ::Celitech::Models::Serializable
+      include ::Celitech::Models::OpenModel
+
+      def self.wire_keys
+        {
+          iccid: 'iccid',
+          data_limit_in_gb: 'dataLimitInGB',
+          start_date: 'startDate',
+          end_date: 'endDate',
+          duration: 'duration',
+          email: 'email',
+          reference_id: 'referenceId',
+          email_brand: 'emailBrand',
+          start_time: 'startTime',
+          end_time: 'endTime',
+        }.freeze
+      end
+
+      def iccid
+        val = @iccid
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def data_limit_in_gb
+        val = @data_limit_in_gb
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def start_date
+        val = @start_date
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def end_date
+        val = @end_date
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def duration
+        val = @duration
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def email
+        val = @email
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def reference_id
+        val = @reference_id
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def email_brand
+        val = @email_brand
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def start_time
+        val = @start_time
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def end_time
+        val = @end_time
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      attr_reader :additional_properties
+
+      def initialize(
+        iccid: ::Celitech::Models::UNSET,
+        data_limit_in_gb: ::Celitech::Models::UNSET,
+        start_date: ::Celitech::Models::UNSET,
+        end_date: ::Celitech::Models::UNSET,
+        duration: ::Celitech::Models::UNSET,
+        email: ::Celitech::Models::UNSET,
+        reference_id: ::Celitech::Models::UNSET,
+        email_brand: ::Celitech::Models::UNSET,
+        start_time: ::Celitech::Models::UNSET,
+        end_time: ::Celitech::Models::UNSET,
+        additional_properties: {}
+      )
+        @iccid = iccid
+        @data_limit_in_gb = data_limit_in_gb
+        @start_date = start_date
+        @end_date = end_date
+        @duration = duration
+        @email = email
+        @reference_id = reference_id
+        @email_brand = email_brand
+        @start_time = start_time
+        @end_time = end_time
+        @additional_properties = additional_properties
+      end
+
+      def self.from_hash(hash)
+        return unless hash
+
+        new(
+          iccid: hash.fetch('iccid', ::Celitech::Models::UNSET),
+          data_limit_in_gb: hash.fetch('dataLimitInGB', ::Celitech::Models::UNSET),
+          start_date: hash.fetch('startDate', ::Celitech::Models::UNSET),
+          end_date: hash.fetch('endDate', ::Celitech::Models::UNSET),
+          duration: hash.fetch('duration', ::Celitech::Models::UNSET),
+          email: hash.fetch('email', ::Celitech::Models::UNSET),
+          reference_id: hash.fetch('referenceId', ::Celitech::Models::UNSET),
+          email_brand: hash.fetch('emailBrand', ::Celitech::Models::UNSET),
+          start_time: hash.fetch('startTime', ::Celitech::Models::UNSET),
+          end_time: hash.fetch('endTime', ::Celitech::Models::UNSET),
+          additional_properties:
+            hash.except('iccid', 'dataLimitInGB', 'startDate', 'endDate', 'duration', 'email', 'referenceId', 'emailBrand', 'startTime', 'endTime'),
+        )
+      end
+
+      def attributes
+        {
+          iccid: @iccid,
+          data_limit_in_gb: @data_limit_in_gb,
+          start_date: @start_date,
+          end_date: @end_date,
+          duration: @duration,
+          email: @email,
+          reference_id: @reference_id,
+          email_brand: @email_brand,
+          start_time: @start_time,
+          end_time: @end_time,
+        }
+      end
+
+      def validate!
+        Validator.validate_string!(@iccid, 'iccid', min_length: 18, max_length: 22) unless @iccid.equal?(::Celitech::Models::UNSET)
+      end
+
+      def open_model_extras
+        @additional_properties
+      end
+    end
+  end
+end

data/lib/celitech/models/unauthorized.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Celitech
+  module Models
+    class Unauthorized
+      include ::Celitech::Models::Serializable
+      include ::Celitech::Models::OpenModel
+
+      def self.wire_keys
+        {
+          message: 'message',
+        }.freeze
+      end
+
+      def message
+        val = @message
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      attr_reader :additional_properties
+
+      def initialize(message: ::Celitech::Models::UNSET, additional_properties: {})
+        @message = message
+        @additional_properties = additional_properties
+      end
+
+      def self.from_hash(hash)
+        return unless hash
+
+        new(
+          message: hash.fetch('message', ::Celitech::Models::UNSET),
+          additional_properties: hash.except('message'),
+        )
+      end
+
+      def attributes
+        {
+          message: @message,
+        }
+      end
+
+      def open_model_extras
+        @additional_properties
+      end
+    end
+  end
+end

data/lib/celitech/models/union_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Celitech
+  module Models
+    # Marker module for oneOf/anyOf union wrapper classes.
+    #
+    # Including classes hold one typed variant in +#value+.
+    # Serializers check for this module to delegate serialization to the wrapped value.
+    module UnionType
+    end
+  end
+end

data/lib/celitech/serializers/form_serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Celitech
+  module Serializers
+    # Serializes models or hashes to form-encoded and multipart bodies.
+    module Form
+      # Encodes a model or hash as application/x-www-form-urlencoded.
+      def self.to_urlencoded(value)
+        URI.encode_www_form(flatten(value))
+      end
+
+      # Configures a Net::HTTP request for multipart/form-data.
+      def self.set_multipart(request, value)
+        request.set_form(
+          flatten(value).map { |k, v| [k.to_s, v.to_s] },
+          'multipart/form-data',
+        )
+      end
+
+      private_class_method def self.flatten(value)
+        value = value.value if value.is_a?(Models::UnionType)
+        if value.is_a?(Models::Serializable)
+          declared = value.class.wire_keys.filter_map do |attr, key|
+            val = value.attributes[attr]
+            # Form encoding cannot represent null; both UNSET and explicit nil are omitted.
+            # Unlike JSON (which serializes nil as null), form bodies have no null concept.
+            [key, val] unless val.nil? || val.equal?(Models::UNSET)
+          end
+          extras = value.is_a?(Models::OpenModel) ? value.open_model_extras.compact.to_a : []
+          declared + extras
+        elsif value.is_a?(Hash)
+          value.compact.to_a
+        else
+          [['body', value.to_s]]
+        end
+      end
+    end
+  end
+end

data/lib/celitech/serializers/json_serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Celitech
+  module Serializers
+    # Serializes models to JSON-ready hashes and deserializes hashes back to models.
+    module Json
+      # Converts a model, array, or primitive to a plain Ruby hash/value
+      # suitable for JSON.generate / .to_json.
+      def self.serialize(value)
+        return value.map { |item| serialize(item) } if value.is_a?(Array)
+        # Typed maps (additionalProperties): serialize values, keeping the dynamic string keys.
+        return value.transform_values { |item| serialize(item) } if value.is_a?(Hash)
+        return serialize(value.value) if value.is_a?(Models::UnionType)
+        return serialize_model(value) if value.is_a?(Models::Serializable)
+
+        value
+      end
+
+      # Builds a model instance from a plain hash (already JSON.parsed).
+      # Returns the raw data unchanged when no model class is provided.
+      def self.deserialize(data, model_class = nil)
+        return data unless model_class
+
+        model_class.from_hash(data)
+      end
+
+      private_class_method def self.serialize_model(model)
+        result = model.class.wire_keys.each_with_object({}) do |(attr, key), hash|
+          val = model.attributes[attr]
+          next if val.equal?(Models::UNSET)
+
+          hash[key] = serialize(val)
+        end
+        model.open_model_extras.each { |k, v| result[k] = serialize(v) unless result.key?(k) } if model.is_a?(Models::OpenModel)
+        result
+      end
+    end
+  end
+end

data/lib/celitech/services/destinations.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Celitech
+  class Destinations
+    NO_OVERRIDE = Object.new.freeze
+    private_constant :NO_OVERRIDE
+
+    def initialize(connection, config = nil, token_manager: nil)
+      @connection = connection
+      @config = config
+      @token_manager = token_manager
+    end
+
+    # List Destinations
+    def list_destinations(config: NO_OVERRIDE)
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      conn = resolve_connection(config)
+      response = conn.get('/destinations', {}, headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::Celitech::Models::ListDestinationsOkResponse.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    rescue APIError => e
+      case e.status
+      when 400
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::BadRequest.from_hash(e.body) : nil
+        raise ::Celitech::BadRequestError.new(e.status, parsed, e.body, e.headers)
+      when 401
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::Unauthorized.from_hash(e.body) : nil
+        raise ::Celitech::UnauthorizedError.new(e.status, parsed, e.body, e.headers)
+      end
+      raise
+    end
+
+    private
+
+    def config_headers(_override_config)
+      return {} unless @token_manager
+
+      @token_manager.headers
+    end
+
+    def resolve_connection(override_config)
+      cfg = override_config.equal?(NO_OVERRIDE) ? @config : override_config
+      return @connection unless cfg&.base_url || cfg&.timeout || cfg&.retry_config
+
+      HTTP::Connection.new(
+        cfg.base_url || @connection.base_url,
+        @connection.default_headers,
+        timeout: cfg.timeout || @connection.timeout,
+        retry_config: cfg.retry_config || @connection.retry_config,
+      )
+    end
+
+    def resolve_config(override_config)
+      override_config.equal?(NO_OVERRIDE) ? @config : override_config
+    end
+  end
+end

data/lib/celitech/services/e_sim.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Celitech
+  class ESim
+    NO_OVERRIDE = Object.new.freeze
+    private_constant :NO_OVERRIDE
+
+    def initialize(connection, config = nil, token_manager: nil)
+      @connection = connection
+      @config = config
+      @token_manager = token_manager
+    end
+
+    # Get eSIM
+    def get_esim(iccid:, config: NO_OVERRIDE)
+      query_params = {
+        'iccid' => iccid,
+      }.compact
+      query_params = query_params.merge(resolve_config(config)&.additional_query_parameters || {})
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      Validator.validate_string!(iccid, 'iccid', min_length: 18, max_length: 22)
+      conn = resolve_connection(config)
+      response = conn.get('/esim', query_params, headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::Celitech::Models::GetEsimOkResponse.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    rescue APIError => e
+      case e.status
+      when 400
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::BadRequest.from_hash(e.body) : nil
+        raise ::Celitech::BadRequestError.new(e.status, parsed, e.body, e.headers)
+      when 401
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::Unauthorized.from_hash(e.body) : nil
+        raise ::Celitech::UnauthorizedError.new(e.status, parsed, e.body, e.headers)
+      end
+      raise
+    end
+
+    # Get eSIM Device
+    def get_esim_device(iccid:, config: NO_OVERRIDE)
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      Validator.validate_string!(iccid, 'iccid', min_length: 18, max_length: 22)
+      conn = resolve_connection(config)
+      response = conn.get("/esim/#{iccid}/device", {}, headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::Celitech::Models::GetEsimDeviceOkResponse.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    rescue APIError => e
+      case e.status
+      when 400
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::BadRequest.from_hash(e.body) : nil
+        raise ::Celitech::BadRequestError.new(e.status, parsed, e.body, e.headers)
+      when 401
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::Unauthorized.from_hash(e.body) : nil
+        raise ::Celitech::UnauthorizedError.new(e.status, parsed, e.body, e.headers)
+      end
+      raise
+    end
+
+    # Get eSIM History
+    def get_esim_history(iccid:, config: NO_OVERRIDE)
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      Validator.validate_string!(iccid, 'iccid', min_length: 18, max_length: 22)
+      conn = resolve_connection(config)
+      response = conn.get("/esim/#{iccid}/history", {}, headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::Celitech::Models::GetEsimHistoryOkResponse.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    rescue APIError => e
+      case e.status
+      when 400
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::BadRequest.from_hash(e.body) : nil
+        raise ::Celitech::BadRequestError.new(e.status, parsed, e.body, e.headers)
+      when 401
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::Unauthorized.from_hash(e.body) : nil
+        raise ::Celitech::UnauthorizedError.new(e.status, parsed, e.body, e.headers)
+      end
+      raise
+    end
+
+    private
+
+    def config_headers(_override_config)
+      return {} unless @token_manager
+
+      @token_manager.headers
+    end
+
+    def resolve_connection(override_config)
+      cfg = override_config.equal?(NO_OVERRIDE) ? @config : override_config
+      return @connection unless cfg&.base_url || cfg&.timeout || cfg&.retry_config
+
+      HTTP::Connection.new(
+        cfg.base_url || @connection.base_url,
+        @connection.default_headers,
+        timeout: cfg.timeout || @connection.timeout,
+        retry_config: cfg.retry_config || @connection.retry_config,
+      )
+    end
+
+    def resolve_config(override_config)
+      override_config.equal?(NO_OVERRIDE) ? @config : override_config
+    end
+  end
+end

data/lib/celitech/services/i_frame.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Celitech
+  class IFrame
+    NO_OVERRIDE = Object.new.freeze
+    private_constant :NO_OVERRIDE
+
+    def initialize(connection, config = nil, token_manager: nil)
+      @connection = connection
+      @config = config
+      @token_manager = token_manager
+    end
+
+    # Generate Token
+    def token(config: NO_OVERRIDE)
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      conn = resolve_connection(config)
+      response = conn.post('/iframe/token', nil, headers: headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::Celitech::Models::TokenOkResponse.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    rescue APIError => e
+      case e.status
+      when 400
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::BadRequest.from_hash(e.body) : nil
+        raise ::Celitech::BadRequestError.new(e.status, parsed, e.body, e.headers)
+      when 401
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::Unauthorized.from_hash(e.body) : nil
+        raise ::Celitech::UnauthorizedError.new(e.status, parsed, e.body, e.headers)
+      end
+      raise
+    end
+
+    private
+
+    def config_headers(_override_config)
+      return {} unless @token_manager
+
+      @token_manager.headers
+    end
+
+    def resolve_connection(override_config)
+      cfg = override_config.equal?(NO_OVERRIDE) ? @config : override_config
+      return @connection unless cfg&.base_url || cfg&.timeout || cfg&.retry_config
+
+      HTTP::Connection.new(
+        cfg.base_url || @connection.base_url,
+        @connection.default_headers,
+        timeout: cfg.timeout || @connection.timeout,
+        retry_config: cfg.retry_config || @connection.retry_config,
+      )
+    end
+
+    def resolve_config(override_config)
+      override_config.equal?(NO_OVERRIDE) ? @config : override_config
+    end
+  end
+end

data/lib/celitech/services/o_auth.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Celitech
+  class OAuth
+    NO_OVERRIDE = Object.new.freeze
+    private_constant :NO_OVERRIDE
+
+    def initialize(connection, config = nil, token_manager: nil)
+      @connection = connection
+      @config = config
+      @token_manager = token_manager
+    end
+
+    def get_access_token(body:, config: NO_OVERRIDE)
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      body.validate! if body.respond_to?(:validate!)
+      conn = resolve_connection(config)
+      response = conn.post('/oauth2/token', body, content_type: 'application/x-www-form-urlencoded', headers: headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::Celitech::Models::OAuthTokenResponse.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    end
+
+    private
+
+    def config_headers(_override_config)
+      return {} unless @token_manager
+
+      @token_manager.headers
+    end
+
+    def resolve_connection(override_config)
+      cfg = override_config.equal?(NO_OVERRIDE) ? @config : override_config
+      return @connection unless cfg&.base_url || cfg&.timeout || cfg&.retry_config
+
+      HTTP::Connection.new(
+        cfg.base_url || @connection.base_url,
+        @connection.default_headers,
+        timeout: cfg.timeout || @connection.timeout,
+        retry_config: cfg.retry_config || @connection.retry_config,
+      )
+    end
+
+    def resolve_config(override_config)
+      override_config.equal?(NO_OVERRIDE) ? @config : override_config
+    end
+  end
+end

data/lib/celitech/services/packages.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Celitech
+  class Packages
+    NO_OVERRIDE = Object.new.freeze
+    private_constant :NO_OVERRIDE
+
+    def initialize(connection, config = nil, token_manager: nil)
+      @connection = connection
+      @config = config
+      @token_manager = token_manager
+    end
+
+    # List Packages
+    def list_packages(
+      destination: nil,
+      data_limit_in_gb: nil,
+      start_date: nil,
+      end_date: nil,
+      after_cursor: nil,
+      limit: nil,
+      start_time: nil,
+      end_time: nil,
+      include_unlimited: nil,
+      config: NO_OVERRIDE
+    )
+      query_params = {
+        'destination' => destination,
+        'dataLimitInGB' => data_limit_in_gb,
+        'startDate' => start_date,
+        'endDate' => end_date,
+        'afterCursor' => after_cursor,
+        'limit' => limit,
+        'startTime' => start_time,
+        'endTime' => end_time,
+        'includeUnlimited' => include_unlimited,
+      }.compact
+      query_params = query_params.merge(resolve_config(config)&.additional_query_parameters || {})
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      conn = resolve_connection(config)
+      response = conn.get('/packages', query_params, headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::Celitech::Models::ListPackagesOkResponse.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    rescue APIError => e
+      case e.status
+      when 400
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::BadRequest.from_hash(e.body) : nil
+        raise ::Celitech::BadRequestError.new(e.status, parsed, e.body, e.headers)
+      when 401
+        parsed = e.body.is_a?(Hash) ? ::Celitech::Models::Unauthorized.from_hash(e.body) : nil
+        raise ::Celitech::UnauthorizedError.new(e.status, parsed, e.body, e.headers)
+      end
+      raise
+    end
+
+    private
+
+    def config_headers(_override_config)
+      return {} unless @token_manager
+
+      @token_manager.headers
+    end
+
+    def resolve_connection(override_config)
+      cfg = override_config.equal?(NO_OVERRIDE) ? @config : override_config
+      return @connection unless cfg&.base_url || cfg&.timeout || cfg&.retry_config
+
+      HTTP::Connection.new(
+        cfg.base_url || @connection.base_url,
+        @connection.default_headers,
+        timeout: cfg.timeout || @connection.timeout,
+        retry_config: cfg.retry_config || @connection.retry_config,
+      )
+    end
+
+    def resolve_config(override_config)
+      override_config.equal?(NO_OVERRIDE) ? @config : override_config
+    end
+  end
+end