stigg 0.1.0.pre.alpha.1 → 0.1.0.pre.alpha.3

data/rbi/stigg/models/v1/subscription_cancel_params.rbi

@@ -0,0 +1,182 @@
+# typed: strong
+
+module Stigg
+  module Models
+    module V1
+      class SubscriptionCancelParams < Stigg::Internal::Type::BaseModel
+        extend Stigg::Internal::Type::RequestParameters::Converter
+        include Stigg::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Stigg::V1::SubscriptionCancelParams, Stigg::Internal::AnyHash)
+          end
+
+        # Action on cancellation (downgrade or revoke)
+        sig do
+          returns(
+            T.nilable(
+              Stigg::V1::SubscriptionCancelParams::CancellationAction::OrSymbol
+            )
+          )
+        end
+        attr_reader :cancellation_action
+
+        sig do
+          params(
+            cancellation_action:
+              Stigg::V1::SubscriptionCancelParams::CancellationAction::OrSymbol
+          ).void
+        end
+        attr_writer :cancellation_action
+
+        # When to cancel (immediate, period end, or date)
+        sig do
+          returns(
+            T.nilable(
+              Stigg::V1::SubscriptionCancelParams::CancellationTime::OrSymbol
+            )
+          )
+        end
+        attr_reader :cancellation_time
+
+        sig do
+          params(
+            cancellation_time:
+              Stigg::V1::SubscriptionCancelParams::CancellationTime::OrSymbol
+          ).void
+        end
+        attr_writer :cancellation_time
+
+        # Subscription end date
+        sig { returns(T.nilable(Time)) }
+        attr_reader :end_date
+
+        sig { params(end_date: Time).void }
+        attr_writer :end_date
+
+        # If set, enables or disables prorating of credits on subscription cancellation.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :prorate
+
+        sig { params(prorate: T::Boolean).void }
+        attr_writer :prorate
+
+        sig do
+          params(
+            cancellation_action:
+              Stigg::V1::SubscriptionCancelParams::CancellationAction::OrSymbol,
+            cancellation_time:
+              Stigg::V1::SubscriptionCancelParams::CancellationTime::OrSymbol,
+            end_date: Time,
+            prorate: T::Boolean,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Action on cancellation (downgrade or revoke)
+          cancellation_action: nil,
+          # When to cancel (immediate, period end, or date)
+          cancellation_time: nil,
+          # Subscription end date
+          end_date: nil,
+          # If set, enables or disables prorating of credits on subscription cancellation.
+          prorate: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              cancellation_action:
+                Stigg::V1::SubscriptionCancelParams::CancellationAction::OrSymbol,
+              cancellation_time:
+                Stigg::V1::SubscriptionCancelParams::CancellationTime::OrSymbol,
+              end_date: Time,
+              prorate: T::Boolean,
+              request_options: Stigg::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Action on cancellation (downgrade or revoke)
+        module CancellationAction
+          extend Stigg::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Stigg::V1::SubscriptionCancelParams::CancellationAction
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DEFAULT =
+            T.let(
+              :DEFAULT,
+              Stigg::V1::SubscriptionCancelParams::CancellationAction::TaggedSymbol
+            )
+          REVOKE_ENTITLEMENTS =
+            T.let(
+              :REVOKE_ENTITLEMENTS,
+              Stigg::V1::SubscriptionCancelParams::CancellationAction::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Stigg::V1::SubscriptionCancelParams::CancellationAction::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # When to cancel (immediate, period end, or date)
+        module CancellationTime
+          extend Stigg::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Stigg::V1::SubscriptionCancelParams::CancellationTime
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          END_OF_BILLING_PERIOD =
+            T.let(
+              :END_OF_BILLING_PERIOD,
+              Stigg::V1::SubscriptionCancelParams::CancellationTime::TaggedSymbol
+            )
+          IMMEDIATE =
+            T.let(
+              :IMMEDIATE,
+              Stigg::V1::SubscriptionCancelParams::CancellationTime::TaggedSymbol
+            )
+          SPECIFIC_DATE =
+            T.let(
+              :SPECIFIC_DATE,
+              Stigg::V1::SubscriptionCancelParams::CancellationTime::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Stigg::V1::SubscriptionCancelParams::CancellationTime::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/models/v1/subscription_delegate_params.rbi

@@ -15,7 +15,9 @@ module Stigg
             )
           end
 
-        # The customer ID to delegate the subscription to
+        # The unique identifier of the customer who will assume payment responsibility for
+        # this subscription. This customer must already exist in your Stigg account and
+        # have a valid payment method if the subscription requires payment.
         sig { returns(String) }
         attr_accessor :target_customer_id
 
@@ -26,7 +28,9 @@ module Stigg
           ).returns(T.attached_class)
         end
         def self.new(
-          # The customer ID to delegate the subscription to
+          # The unique identifier of the customer who will assume payment responsibility for
+          # this subscription. This customer must already exist in your Stigg account and
+          # have a valid payment method if the subscription requires payment.
           target_customer_id:,
           request_options: {}
         )

data/rbi/stigg/models/v1/subscription_import_params.rbi

@@ -0,0 +1,148 @@
+# typed: strong
+
+module Stigg
+  module Models
+    module V1
+      class SubscriptionImportParams < Stigg::Internal::Type::BaseModel
+        extend Stigg::Internal::Type::RequestParameters::Converter
+        include Stigg::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Stigg::V1::SubscriptionImportParams, Stigg::Internal::AnyHash)
+          end
+
+        # List of subscription objects to import
+        sig do
+          returns(T::Array[Stigg::V1::SubscriptionImportParams::Subscription])
+        end
+        attr_accessor :subscriptions
+
+        sig do
+          params(
+            subscriptions:
+              T::Array[
+                Stigg::V1::SubscriptionImportParams::Subscription::OrHash
+              ],
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # List of subscription objects to import
+          subscriptions:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              subscriptions:
+                T::Array[Stigg::V1::SubscriptionImportParams::Subscription],
+              request_options: Stigg::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Subscription < Stigg::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Stigg::V1::SubscriptionImportParams::Subscription,
+                Stigg::Internal::AnyHash
+              )
+            end
+
+          # Subscription ID
+          sig { returns(String) }
+          attr_accessor :id
+
+          # Customer ID
+          sig { returns(String) }
+          attr_accessor :customer_id
+
+          # Plan ID
+          sig { returns(String) }
+          attr_accessor :plan_id
+
+          # Billing ID
+          sig { returns(T.nilable(String)) }
+          attr_accessor :billing_id
+
+          # Subscription end date
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :end_date
+
+          # Additional metadata for the subscription
+          sig { returns(T.nilable(T::Hash[Symbol, String])) }
+          attr_reader :metadata
+
+          sig { params(metadata: T::Hash[Symbol, String]).void }
+          attr_writer :metadata
+
+          # Resource ID
+          sig { returns(T.nilable(String)) }
+          attr_accessor :resource_id
+
+          # Subscription start date
+          sig { returns(T.nilable(Time)) }
+          attr_reader :start_date
+
+          sig { params(start_date: Time).void }
+          attr_writer :start_date
+
+          sig do
+            params(
+              id: String,
+              customer_id: String,
+              plan_id: String,
+              billing_id: T.nilable(String),
+              end_date: T.nilable(Time),
+              metadata: T::Hash[Symbol, String],
+              resource_id: T.nilable(String),
+              start_date: Time
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Subscription ID
+            id:,
+            # Customer ID
+            customer_id:,
+            # Plan ID
+            plan_id:,
+            # Billing ID
+            billing_id: nil,
+            # Subscription end date
+            end_date: nil,
+            # Additional metadata for the subscription
+            metadata: nil,
+            # Resource ID
+            resource_id: nil,
+            # Subscription start date
+            start_date: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                customer_id: String,
+                plan_id: String,
+                billing_id: T.nilable(String),
+                end_date: T.nilable(Time),
+                metadata: T::Hash[Symbol, String],
+                resource_id: T.nilable(String),
+                start_date: Time
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/models/v1/subscription_import_response.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Stigg
+  module Models
+    module V1
+      class SubscriptionImportResponse < Stigg::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Stigg::Models::V1::SubscriptionImportResponse,
+              Stigg::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Stigg::Models::V1::SubscriptionImportResponse::Data) }
+        attr_reader :data
+
+        sig do
+          params(
+            data: Stigg::Models::V1::SubscriptionImportResponse::Data::OrHash
+          ).void
+        end
+        attr_writer :data
+
+        # Response object
+        sig do
+          params(
+            data: Stigg::Models::V1::SubscriptionImportResponse::Data::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(data:)
+        end
+
+        sig do
+          override.returns(
+            { data: Stigg::Models::V1::SubscriptionImportResponse::Data }
+          )
+        end
+        def to_hash
+        end
+
+        class Data < Stigg::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Stigg::Models::V1::SubscriptionImportResponse::Data,
+                Stigg::Internal::AnyHash
+              )
+            end
+
+          # Unique identifier for the import task
+          sig { returns(String) }
+          attr_accessor :task_id
+
+          sig { params(task_id: String).returns(T.attached_class) }
+          def self.new(
+            # Unique identifier for the import task
+            task_id:
+          )
+          end
+
+          sig { override.returns({ task_id: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/models/v1/subscription_list_params.rbi

@@ -12,6 +12,20 @@ module Stigg
             T.any(Stigg::V1::SubscriptionListParams, Stigg::Internal::AnyHash)
           end
 
+        # Return items that come after this cursor
+        sig { returns(T.nilable(String)) }
+        attr_reader :after
+
+        sig { params(after: String).void }
+        attr_writer :after
+
+        # Return items that come before this cursor
+        sig { returns(T.nilable(String)) }
+        attr_reader :before
+
+        sig { params(before: String).void }
+        attr_writer :before
+
         # Filter by customer ID
         sig { returns(T.nilable(String)) }
         attr_reader :customer_id
@@ -19,29 +33,14 @@ module Stigg
         sig { params(customer_id: String).void }
         attr_writer :customer_id
 
-        # Ending before this UUID for pagination
-        sig { returns(T.nilable(String)) }
-        attr_reader :ending_before
-
-        sig { params(ending_before: String).void }
-        attr_writer :ending_before
-
-        # Items per page
+        # Maximum number of items to return
         sig { returns(T.nilable(Integer)) }
         attr_reader :limit
 
         sig { params(limit: Integer).void }
         attr_writer :limit
 
-        # Starting after this UUID for pagination
-        sig { returns(T.nilable(String)) }
-        attr_reader :starting_after
-
-        sig { params(starting_after: String).void }
-        attr_writer :starting_after
-
-        # Filter by subscription status (comma-separated for multiple statuses, e.g.,
-        # ACTIVE,IN_TRIAL)
+        # Filter by status (comma-separated)
         sig { returns(T.nilable(String)) }
         attr_reader :status
 
@@ -50,25 +49,24 @@ module Stigg
 
         sig do
           params(
+            after: String,
+            before: String,
             customer_id: String,
-            ending_before: String,
             limit: Integer,
-            starting_after: String,
             status: String,
             request_options: Stigg::RequestOptions::OrHash
           ).returns(T.attached_class)
         end
         def self.new(
+          # Return items that come after this cursor
+          after: nil,
+          # Return items that come before this cursor
+          before: nil,
           # Filter by customer ID
           customer_id: nil,
-          # Ending before this UUID for pagination
-          ending_before: nil,
-          # Items per page
+          # Maximum number of items to return
           limit: nil,
-          # Starting after this UUID for pagination
-          starting_after: nil,
-          # Filter by subscription status (comma-separated for multiple statuses, e.g.,
-          # ACTIVE,IN_TRIAL)
+          # Filter by status (comma-separated)
           status: nil,
           request_options: {}
         )
@@ -77,10 +75,10 @@ module Stigg
         sig do
           override.returns(
             {
+              after: String,
+              before: String,
               customer_id: String,
-              ending_before: String,
               limit: Integer,
-              starting_after: String,
               status: String,
               request_options: Stigg::RequestOptions
             }