stigg 0.1.0.pre.alpha.1

data/rbi/stigg/resources/v1/coupons.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Stigg
+  module Resources
+    class V1
+      class Coupons
+        # Create a new Coupon
+        sig do
+          params(
+            id: String,
+            amounts_off:
+              T.nilable(
+                T::Array[Stigg::V1::CouponCreateParams::AmountsOff::OrHash]
+              ),
+            description: T.nilable(String),
+            duration_in_months: T.nilable(Integer),
+            name: String,
+            percent_off: T.nilable(Float),
+            additional_meta_data: T.anything,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::CouponCreateResponse)
+        end
+        def create(
+          # The unique identifier for the entity
+          id:,
+          # Fixed amount discounts in different currencies
+          amounts_off:,
+          # Description of the coupon
+          description:,
+          # Duration of the coupon validity in months
+          duration_in_months:,
+          # Name of the coupon
+          name:,
+          # Percentage discount off the original price
+          percent_off:,
+          # Metadata associated with the entity
+          additional_meta_data: nil,
+          request_options: {}
+        )
+        end
+
+        # Get a single Coupon by id
+        sig do
+          params(
+            id: String,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::CouponRetrieveResponse)
+        end
+        def retrieve(id, request_options: {})
+        end
+
+        # Get a list of Coupons
+        sig do
+          params(
+            ending_before: String,
+            limit: Integer,
+            starting_after: String,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::CouponListResponse)
+        end
+        def list(
+          # Ending before this UUID for pagination
+          ending_before: nil,
+          # Items per page
+          limit: nil,
+          # Starting after this UUID for pagination
+          starting_after: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Stigg::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/resources/v1/customers/payment_method.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Stigg
+  module Resources
+    class V1
+      class Customers
+        class PaymentMethod
+          # Perform payment-method attachment on a Customer
+          sig do
+            params(
+              id: String,
+              integration_id: String,
+              payment_method_id: String,
+              vendor_identifier:
+                Stigg::V1::Customers::PaymentMethodAttachParams::VendorIdentifier::OrSymbol,
+              billing_currency:
+                T.nilable(
+                  Stigg::V1::Customers::PaymentMethodAttachParams::BillingCurrency::OrSymbol
+                ),
+              request_options: Stigg::RequestOptions::OrHash
+            ).returns(Stigg::V1::CustomerResponse)
+          end
+          def attach(
+            id,
+            # Integration details
+            integration_id:,
+            # Billing provider payment method id
+            payment_method_id:,
+            # The vendor identifier of integration
+            vendor_identifier:,
+            billing_currency: nil,
+            request_options: {}
+          )
+          end
+
+          # Perform payment-method detachment on a Customer
+          sig do
+            params(
+              id: String,
+              request_options: Stigg::RequestOptions::OrHash
+            ).returns(Stigg::V1::CustomerResponse)
+          end
+          def detach(id, request_options: {})
+          end
+
+          # @api private
+          sig { params(client: Stigg::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/resources/v1/customers/promotional.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Stigg
+  module Resources
+    class V1
+      class Customers
+        class Promotional
+          # Create a new Promotional Entitlements
+          sig do
+            params(
+              customer_id: String,
+              promotional_entitlements:
+                T::Array[
+                  Stigg::V1::Customers::PromotionalCreateParams::PromotionalEntitlement::OrHash
+                ],
+              request_options: Stigg::RequestOptions::OrHash
+            ).returns(Stigg::Models::V1::Customers::PromotionalCreateResponse)
+          end
+          def create(
+            # The unique identifier of the entitlement customer
+            customer_id,
+            # Promotional entitlements to grant
+            promotional_entitlements:,
+            request_options: {}
+          )
+          end
+
+          # Perform revocation on a Promotional Entitlement
+          sig do
+            params(
+              feature_id: String,
+              customer_id: String,
+              request_options: Stigg::RequestOptions::OrHash
+            ).returns(Stigg::Models::V1::Customers::PromotionalRevokeResponse)
+          end
+          def revoke(
+            # The unique identifier of the entitlement feature
+            feature_id,
+            # The unique identifier of the entitlement customer
+            customer_id:,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Stigg::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/resources/v1/customers/usage.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Stigg
+  module Resources
+    class V1
+      class Customers
+        class Usage
+          # Perform retrieval on a Usage history
+          sig do
+            params(
+              feature_id: String,
+              customer_id: String,
+              start_date: Time,
+              end_date: Time,
+              group_by: String,
+              resource_id: T.nilable(String),
+              request_options: Stigg::RequestOptions::OrHash
+            ).returns(Stigg::Models::V1::Customers::UsageRetrieveResponse)
+          end
+          def retrieve(
+            # Path param: Feature id
+            feature_id,
+            # Path param: Customer id
+            customer_id:,
+            # Query param: The start date of the range
+            start_date:,
+            # Query param: The end date of the range
+            end_date: nil,
+            # Query param
+            group_by: nil,
+            # Query param: Resource id
+            resource_id: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Stigg::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/resources/v1/customers.rbi

@@ -0,0 +1,138 @@
+# typed: strong
+
+module Stigg
+  module Resources
+    class V1
+      class Customers
+        sig { returns(Stigg::Resources::V1::Customers::PaymentMethod) }
+        attr_reader :payment_method
+
+        sig { returns(Stigg::Resources::V1::Customers::Usage) }
+        attr_reader :usage
+
+        sig { returns(Stigg::Resources::V1::Customers::Promotional) }
+        attr_reader :promotional
+
+        # Create a new Customer
+        sig do
+          params(
+            id: String,
+            coupon_id: T.nilable(String),
+            default_payment_method:
+              T.nilable(
+                Stigg::V1::CustomerCreateParams::DefaultPaymentMethod::OrHash
+              ),
+            email: T.nilable(String),
+            integrations:
+              T::Array[Stigg::V1::CustomerCreateParams::Integration::OrHash],
+            metadata: T::Hash[Symbol, String],
+            name: T.nilable(String),
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::V1::CustomerResponse)
+        end
+        def create(
+          # Customer slug
+          id:,
+          # Customer level coupon
+          coupon_id: nil,
+          # The default payment method details
+          default_payment_method: nil,
+          # The email of the customer
+          email: nil,
+          # List of integrations
+          integrations: nil,
+          # Additional metadata
+          metadata: nil,
+          # The name of the customer
+          name: nil,
+          request_options: {}
+        )
+        end
+
+        # Get a single Customer by id
+        sig do
+          params(
+            id: String,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::V1::CustomerResponse)
+        end
+        def retrieve(id, request_options: {})
+        end
+
+        # Update an existing Customer
+        sig do
+          params(
+            id: String,
+            coupon_id: T.nilable(String),
+            email: T.nilable(String),
+            integrations:
+              T::Array[Stigg::V1::CustomerUpdateParams::Integration::OrHash],
+            metadata: T::Hash[Symbol, String],
+            name: T.nilable(String),
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::V1::CustomerResponse)
+        end
+        def update(
+          id,
+          # Customer level coupon
+          coupon_id: nil,
+          # The email of the customer
+          email: nil,
+          # List of integrations
+          integrations: nil,
+          # Additional metadata
+          metadata: nil,
+          # The name of the customer
+          name: nil,
+          request_options: {}
+        )
+        end
+
+        # Get a list of Customers
+        sig do
+          params(
+            ending_before: String,
+            limit: Integer,
+            starting_after: String,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::CustomerListResponse)
+        end
+        def list(
+          # Ending before this UUID for pagination
+          ending_before: nil,
+          # Items per page
+          limit: nil,
+          # Starting after this UUID for pagination
+          starting_after: nil,
+          request_options: {}
+        )
+        end
+
+        # Perform archive on a Customer
+        sig do
+          params(
+            id: String,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::V1::CustomerResponse)
+        end
+        def archive(id, request_options: {})
+        end
+
+        # Perform unarchive on a Customer
+        sig do
+          params(
+            id: String,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::V1::CustomerResponse)
+        end
+        def unarchive(id, request_options: {})
+        end
+
+        # @api private
+        sig { params(client: Stigg::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/resources/v1/subscriptions/future_update.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Stigg
+  module Resources
+    class V1
+      class Subscriptions
+        class FutureUpdate
+          # Perform cancel future update on a Subscription
+          sig do
+            params(
+              id: String,
+              request_options: Stigg::RequestOptions::OrHash
+            ).returns(
+              Stigg::Models::V1::Subscriptions::FutureUpdateCancelPendingPaymentResponse
+            )
+          end
+          def cancel_pending_payment(id, request_options: {})
+          end
+
+          # Perform cancel future update on a Subscription
+          sig do
+            params(
+              id: String,
+              request_options: Stigg::RequestOptions::OrHash
+            ).returns(
+              Stigg::Models::V1::Subscriptions::FutureUpdateCancelScheduleResponse
+            )
+          end
+          def cancel_schedule(id, request_options: {})
+          end
+
+          # @api private
+          sig { params(client: Stigg::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/resources/v1/subscriptions.rbi

@@ -0,0 +1,199 @@
+# typed: strong
+
+module Stigg
+  module Resources
+    class V1
+      class Subscriptions
+        sig { returns(Stigg::Resources::V1::Subscriptions::FutureUpdate) }
+        attr_reader :future_update
+
+        # Create a new Subscription
+        sig do
+          params(
+            customer_id: String,
+            plan_id: String,
+            id: T.nilable(String),
+            await_payment_confirmation: T::Boolean,
+            billing_period:
+              Stigg::V1::SubscriptionCreateParams::BillingPeriod::OrSymbol,
+            checkout_options:
+              Stigg::V1::SubscriptionCreateParams::CheckoutOptions::OrHash,
+            metadata: T::Hash[Symbol, String],
+            paying_customer_id: T.nilable(String),
+            resource_id: T.nilable(String),
+            trial_override_configuration:
+              Stigg::V1::SubscriptionCreateParams::TrialOverrideConfiguration::OrHash,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::SubscriptionCreateResponse)
+        end
+        def create(
+          # Customer ID to provision the subscription for
+          customer_id:,
+          # Plan ID to provision
+          plan_id:,
+          # Unique identifier for the subscription
+          id: nil,
+          # Whether to wait for payment confirmation before returning the subscription
+          await_payment_confirmation: nil,
+          billing_period: nil,
+          checkout_options: nil,
+          # Additional metadata for the subscription
+          metadata: nil,
+          # Optional paying customer ID for split billing scenarios
+          paying_customer_id: nil,
+          # Optional resource ID for multi-instance subscriptions
+          resource_id: nil,
+          trial_override_configuration: nil,
+          request_options: {}
+        )
+        end
+
+        # Get a single Subscription by id
+        sig do
+          params(
+            id: String,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::SubscriptionRetrieveResponse)
+        end
+        def retrieve(id, request_options: {})
+        end
+
+        # Get a list of Subscriptions
+        sig do
+          params(
+            customer_id: String,
+            ending_before: String,
+            limit: Integer,
+            starting_after: String,
+            status: String,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::SubscriptionListResponse)
+        end
+        def list(
+          # Filter by customer ID
+          customer_id: nil,
+          # Ending before this UUID for pagination
+          ending_before: nil,
+          # Items per page
+          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)
+          status: nil,
+          request_options: {}
+        )
+        end
+
+        # Perform delegate on a Subscription
+        sig do
+          params(
+            id: String,
+            target_customer_id: String,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::SubscriptionDelegateResponse)
+        end
+        def delegate(
+          id,
+          # The customer ID to delegate the subscription to
+          target_customer_id:,
+          request_options: {}
+        )
+        end
+
+        # Perform migrate to latest plan version on a Subscription
+        sig do
+          params(
+            id: String,
+            subscription_migration_time:
+              Stigg::V1::SubscriptionMigrateParams::SubscriptionMigrationTime::OrSymbol,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::SubscriptionMigrateResponse)
+        end
+        def migrate(
+          id,
+          # When to migrate the subscription: IMMEDIATE or END_OF_BILLING_PERIOD
+          subscription_migration_time: nil,
+          request_options: {}
+        )
+        end
+
+        # Create a new Subscription Preview
+        sig do
+          params(
+            customer_id: String,
+            plan_id: String,
+            addons:
+              T::Array[Stigg::V1::SubscriptionPreviewParams::Addon::OrHash],
+            applied_coupon:
+              Stigg::V1::SubscriptionPreviewParams::AppliedCoupon::OrHash,
+            billable_features:
+              T::Array[
+                Stigg::V1::SubscriptionPreviewParams::BillableFeature::OrHash
+              ],
+            billing_country_code: String,
+            billing_information:
+              Stigg::V1::SubscriptionPreviewParams::BillingInformation::OrHash,
+            billing_period:
+              Stigg::V1::SubscriptionPreviewParams::BillingPeriod::OrSymbol,
+            charges:
+              T::Array[Stigg::V1::SubscriptionPreviewParams::Charge::OrHash],
+            paying_customer_id: String,
+            resource_id: String,
+            schedule_strategy:
+              Stigg::V1::SubscriptionPreviewParams::ScheduleStrategy::OrSymbol,
+            start_date: Time,
+            trial_override_configuration:
+              Stigg::V1::SubscriptionPreviewParams::TrialOverrideConfiguration::OrHash,
+            unit_quantity: Float,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::SubscriptionPreviewResponse)
+        end
+        def preview(
+          # Customer ID
+          customer_id:,
+          # Plan ID
+          plan_id:,
+          addons: nil,
+          applied_coupon: nil,
+          billable_features: nil,
+          billing_country_code: nil,
+          billing_information: nil,
+          billing_period: nil,
+          charges: nil,
+          paying_customer_id: nil,
+          resource_id: nil,
+          schedule_strategy: nil,
+          # Subscription start date
+          start_date: nil,
+          trial_override_configuration: nil,
+          unit_quantity: nil,
+          request_options: {}
+        )
+        end
+
+        # Perform transfer to resource on a Subscription
+        sig do
+          params(
+            id: String,
+            destination_resource_id: String,
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(Stigg::Models::V1::SubscriptionTransferResponse)
+        end
+        def transfer(
+          id,
+          # The resource ID to transfer the subscription to. The destination resource must
+          # belong to the same customer.
+          destination_resource_id:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Stigg::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/resources/v1.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Stigg
+  module Resources
+    class V1
+      sig { returns(Stigg::Resources::V1::Customers) }
+      attr_reader :customers
+
+      sig { returns(Stigg::Resources::V1::Subscriptions) }
+      attr_reader :subscriptions
+
+      sig { returns(Stigg::Resources::V1::Coupons) }
+      attr_reader :coupons
+
+      # Create events
+      sig do
+        params(
+          events: T::Array[Stigg::V1CreateEventParams::Event::OrHash],
+          request_options: Stigg::RequestOptions::OrHash
+        ).returns(Stigg::Models::V1CreateEventResponse)
+      end
+      def create_event(
+        # A list of usage events to report
+        events:,
+        request_options: {}
+      )
+      end
+
+      # Create a new Usage
+      sig do
+        params(
+          usages: T::Array[Stigg::V1CreateUsageParams::Usage::OrHash],
+          request_options: Stigg::RequestOptions::OrHash
+        ).returns(Stigg::Models::V1CreateUsageResponse)
+      end
+      def create_usage(
+        # A list of usage reports to be submitted in bulk
+        usages:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Stigg::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/stigg/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module Stigg
+  VERSION = T.let(T.unsafe(nil), String)
+end

data/sig/stigg/client.rbs

@@ -0,0 +1,26 @@
+module Stigg
+  class Client < Stigg::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES: 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS: Float
+
+    DEFAULT_INITIAL_RETRY_DELAY: Float
+
+    DEFAULT_MAX_RETRY_DELAY: Float
+
+    attr_reader api_key: String
+
+    attr_reader v1: Stigg::Resources::V1
+
+    private def auth_headers: -> ::Hash[String, String]
+
+    def initialize: (
+      ?api_key: String?,
+      ?base_url: String?,
+      ?max_retries: Integer,
+      ?timeout: Float,
+      ?initial_retry_delay: Float,
+      ?max_retry_delay: Float
+    ) -> void
+  end
+end