shopify_api 9.5.1 → 10.0.0

data/lib/shopify_api/rest/resources/2021_10/page.rb

@@ -0,0 +1,190 @@
+# typed: false
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class Page < ShopifyAPI::Rest::Base
+    extend T::Sig
+
+    @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
+    def initialize(session: ShopifyAPI::Context.active_session)
+      super(session: session)
+
+      @admin_graphql_api_id = T.let(nil, T.nilable(String))
+      @author = T.let(nil, T.nilable(String))
+      @body_html = T.let(nil, T.nilable(String))
+      @created_at = T.let(nil, T.nilable(String))
+      @handle = T.let(nil, T.nilable(String))
+      @id = T.let(nil, T.nilable(Integer))
+      @metafield = T.let(nil, T.nilable(Metafield))
+      @published_at = T.let(nil, T.nilable(String))
+      @shop_id = T.let(nil, T.nilable(Integer))
+      @template_suffix = T.let(nil, T.nilable(String))
+      @title = T.let(nil, T.nilable(String))
+      @updated_at = T.let(nil, T.nilable(String))
+    end
+
+    @has_one = T.let({
+      metafield: Metafield
+    }, T::Hash[Symbol, Class])
+    @has_many = T.let({}, T::Hash[Symbol, Class])
+    @paths = T.let([
+      {http_method: :delete, operation: :delete, ids: [:id], path: "pages/<id>.json"},
+      {http_method: :get, operation: :count, ids: [], path: "pages/count.json"},
+      {http_method: :get, operation: :get, ids: [], path: "pages.json"},
+      {http_method: :get, operation: :get, ids: [:id], path: "pages/<id>.json"},
+      {http_method: :post, operation: :post, ids: [], path: "pages.json"},
+      {http_method: :put, operation: :put, ids: [:id], path: "pages/<id>.json"}
+    ], T::Array[T::Hash[String, T.any(T::Array[Symbol], String, Symbol)]])
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :admin_graphql_api_id
+    sig { returns(T.nilable(String)) }
+    attr_reader :author
+    sig { returns(T.nilable(String)) }
+    attr_reader :body_html
+    sig { returns(T.nilable(String)) }
+    attr_reader :created_at
+    sig { returns(T.nilable(String)) }
+    attr_reader :handle
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :id
+    sig { returns(T.nilable(Metafield)) }
+    attr_reader :metafield
+    sig { returns(T.nilable(String)) }
+    attr_reader :published_at
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :shop_id
+    sig { returns(T.nilable(String)) }
+    attr_reader :template_suffix
+    sig { returns(T.nilable(String)) }
+    attr_reader :title
+    sig { returns(T.nilable(String)) }
+    attr_reader :updated_at
+
+    class << self
+      sig do
+        params(
+          id: T.any(Integer, String),
+          fields: T.untyped,
+          session: Auth::Session
+        ).returns(T.nilable(Page))
+      end
+      def find(
+        id:,
+        fields: nil,
+        session: ShopifyAPI::Context.active_session
+      )
+        result = base_find(
+          session: session,
+          ids: {id: id},
+          params: {fields: fields},
+        )
+        T.cast(result[0], T.nilable(Page))
+      end
+
+      sig do
+        params(
+          id: T.any(Integer, String),
+          session: Auth::Session
+        ).returns(T.untyped)
+      end
+      def delete(
+        id:,
+        session: ShopifyAPI::Context.active_session
+      )
+        request(
+          http_method: :delete,
+          operation: :delete,
+          session: session,
+          ids: {id: id},
+          params: {},
+        )
+      end
+
+      sig do
+        params(
+          limit: T.untyped,
+          since_id: T.untyped,
+          title: T.untyped,
+          handle: T.untyped,
+          created_at_min: T.untyped,
+          created_at_max: T.untyped,
+          updated_at_min: T.untyped,
+          updated_at_max: T.untyped,
+          published_at_min: T.untyped,
+          published_at_max: T.untyped,
+          fields: T.untyped,
+          published_status: T.untyped,
+          session: Auth::Session,
+          kwargs: T.untyped
+        ).returns(T::Array[Page])
+      end
+      def all(
+        limit: nil,
+        since_id: nil,
+        title: nil,
+        handle: nil,
+        created_at_min: nil,
+        created_at_max: nil,
+        updated_at_min: nil,
+        updated_at_max: nil,
+        published_at_min: nil,
+        published_at_max: nil,
+        fields: nil,
+        published_status: nil,
+        session: ShopifyAPI::Context.active_session,
+        **kwargs
+      )
+        response = base_find(
+          session: session,
+          ids: {},
+          params: {limit: limit, since_id: since_id, title: title, handle: handle, created_at_min: created_at_min, created_at_max: created_at_max, updated_at_min: updated_at_min, updated_at_max: updated_at_max, published_at_min: published_at_min, published_at_max: published_at_max, fields: fields, published_status: published_status}.merge(kwargs).compact,
+        )
+
+        T.cast(response, T::Array[Page])
+      end
+
+      sig do
+        params(
+          title: T.untyped,
+          created_at_min: T.untyped,
+          created_at_max: T.untyped,
+          updated_at_min: T.untyped,
+          updated_at_max: T.untyped,
+          published_at_min: T.untyped,
+          published_at_max: T.untyped,
+          published_status: T.untyped,
+          session: Auth::Session,
+          kwargs: T.untyped
+        ).returns(T.untyped)
+      end
+      def count(
+        title: nil,
+        created_at_min: nil,
+        created_at_max: nil,
+        updated_at_min: nil,
+        updated_at_max: nil,
+        published_at_min: nil,
+        published_at_max: nil,
+        published_status: nil,
+        session: ShopifyAPI::Context.active_session,
+        **kwargs
+      )
+        request(
+          http_method: :get,
+          operation: :count,
+          session: session,
+          ids: {},
+          params: {title: title, created_at_min: created_at_min, created_at_max: created_at_max, updated_at_min: updated_at_min, updated_at_max: updated_at_max, published_at_min: published_at_min, published_at_max: published_at_max, published_status: published_status}.merge(kwargs).compact,
+          body: {},
+          entity: nil,
+        )
+      end
+
+    end
+
+  end
+end

data/lib/shopify_api/rest/resources/2021_10/payment.rb

@@ -0,0 +1,136 @@
+# typed: false
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class Payment < ShopifyAPI::Rest::Base
+    extend T::Sig
+
+    @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
+    def initialize(session: ShopifyAPI::Context.active_session)
+      super(session: session)
+
+      @checkout = T.let(nil, T.nilable(Checkout))
+      @credit_card = T.let(nil, T.nilable(T::Hash[T.untyped, T.untyped]))
+      @id = T.let(nil, T.nilable(Integer))
+      @next_action = T.let(nil, T.nilable(T::Hash[T.untyped, T.untyped]))
+      @payment_processing_error_message = T.let(nil, T.nilable(String))
+      @transaction = T.let(nil, T.nilable(Transaction))
+      @unique_token = T.let(nil, T.nilable(String))
+    end
+
+    @has_one = T.let({
+      transaction: Transaction,
+      checkout: Checkout
+    }, T::Hash[Symbol, Class])
+    @has_many = T.let({}, T::Hash[Symbol, Class])
+    @paths = T.let([
+      {http_method: :get, operation: :count, ids: [:checkout_id], path: "checkouts/<checkout_id>/payments/count.json"},
+      {http_method: :get, operation: :get, ids: [:checkout_id], path: "checkouts/<checkout_id>/payments.json"},
+      {http_method: :get, operation: :get, ids: [:checkout_id, :id], path: "checkouts/<checkout_id>/payments/<id>.json"},
+      {http_method: :post, operation: :post, ids: [:checkout_id], path: "checkouts/<checkout_id>/payments.json"}
+    ], T::Array[T::Hash[String, T.any(T::Array[Symbol], String, Symbol)]])
+
+    sig { returns(T.nilable(Checkout)) }
+    attr_reader :checkout
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    attr_reader :credit_card
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :id
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    attr_reader :next_action
+    sig { returns(T.nilable(String)) }
+    attr_reader :payment_processing_error_message
+    sig { returns(T.nilable(Transaction)) }
+    attr_reader :transaction
+    sig { returns(T.nilable(String)) }
+    attr_reader :unique_token
+
+    class << self
+      sig do
+        params(
+          id: T.any(Integer, String),
+          checkout_id: T.nilable(T.any(Integer, String)),
+          session: Auth::Session
+        ).returns(T.nilable(Payment))
+      end
+      def find(
+        id:,
+        checkout_id: nil,
+        session: ShopifyAPI::Context.active_session
+      )
+        result = base_find(
+          session: session,
+          ids: {id: id, checkout_id: checkout_id},
+          params: {},
+        )
+        T.cast(result[0], T.nilable(Payment))
+      end
+
+      sig do
+        params(
+          checkout_id: T.nilable(T.any(Integer, String)),
+          session: Auth::Session,
+          kwargs: T.untyped
+        ).returns(T::Array[Payment])
+      end
+      def all(
+        checkout_id: nil,
+        session: ShopifyAPI::Context.active_session,
+        **kwargs
+      )
+        response = base_find(
+          session: session,
+          ids: {checkout_id: checkout_id},
+          params: {}.merge(kwargs).compact,
+        )
+
+        T.cast(response, T::Array[Payment])
+      end
+
+      sig do
+        params(
+          checkout_id: T.nilable(T.any(Integer, String)),
+          session: Auth::Session,
+          kwargs: T.untyped
+        ).returns(T.untyped)
+      end
+      def count(
+        checkout_id: nil,
+        session: ShopifyAPI::Context.active_session,
+        **kwargs
+      )
+        request(
+          http_method: :get,
+          operation: :count,
+          session: session,
+          ids: {checkout_id: checkout_id},
+          params: {}.merge(kwargs).compact,
+          body: {},
+          entity: nil,
+        )
+      end
+
+    end
+
+    sig do
+      returns(T.untyped)
+    end
+    def checkout_id()
+      @checkout&.token
+    end
+
+    sig do
+      params(
+        val: T.untyped
+      ).void
+    end
+    def checkout_id=(val)
+      @checkout = @checkout || Checkout.new(session: @session)
+      T.unsafe(@checkout).token = val
+    end
+
+  end
+end

data/lib/shopify_api/rest/resources/2021_10/payment_gateway.rb

@@ -0,0 +1,139 @@
+# typed: false
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class PaymentGateway < ShopifyAPI::Rest::Base
+    extend T::Sig
+
+    @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
+    def initialize(session: ShopifyAPI::Context.active_session)
+      super(session: session)
+
+      @attachment = T.let(nil, T.nilable(String))
+      @created_at = T.let(nil, T.nilable(String))
+      @credential1 = T.let(nil, T.nilable(String))
+      @credential2 = T.let(nil, T.nilable(String))
+      @credential3 = T.let(nil, T.nilable(String))
+      @credential4 = T.let(nil, T.nilable(String))
+      @disabled = T.let(nil, T.nilable(T::Boolean))
+      @enabled_card_brands = T.let(nil, T.nilable(T::Array[T.untyped]))
+      @id = T.let(nil, T.nilable(Integer))
+      @name = T.let(nil, T.nilable(String))
+      @processing_method = T.let(nil, T.nilable(String))
+      @provider_id = T.let(nil, T.nilable(Integer))
+      @sandbox = T.let(nil, T.nilable(T::Boolean))
+      @service_name = T.let(nil, T.nilable(String))
+      @supports_network_tokenization = T.let(nil, T.nilable(T::Boolean))
+      @type = T.let(nil, T.nilable(String))
+      @updated_at = T.let(nil, T.nilable(String))
+    end
+
+    @has_one = T.let({}, T::Hash[Symbol, Class])
+    @has_many = T.let({}, T::Hash[Symbol, Class])
+    @paths = T.let([
+      {http_method: :delete, operation: :delete, ids: [:id], path: "payment_gateways/<id>.json"},
+      {http_method: :get, operation: :get, ids: [], path: "payment_gateways.json"},
+      {http_method: :get, operation: :get, ids: [:id], path: "payment_gateways/<id>.json"},
+      {http_method: :post, operation: :post, ids: [], path: "payment_gateways.json"},
+      {http_method: :put, operation: :put, ids: [:id], path: "payment_gateways/<id>.json"}
+    ], T::Array[T::Hash[String, T.any(T::Array[Symbol], String, Symbol)]])
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :attachment
+    sig { returns(T.nilable(String)) }
+    attr_reader :created_at
+    sig { returns(T.nilable(String)) }
+    attr_reader :credential1
+    sig { returns(T.nilable(String)) }
+    attr_reader :credential2
+    sig { returns(T.nilable(String)) }
+    attr_reader :credential3
+    sig { returns(T.nilable(String)) }
+    attr_reader :credential4
+    sig { returns(T.nilable(T::Boolean)) }
+    attr_reader :disabled
+    sig { returns(T.nilable(T::Array[String])) }
+    attr_reader :enabled_card_brands
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :id
+    sig { returns(T.nilable(String)) }
+    attr_reader :name
+    sig { returns(T.nilable(String)) }
+    attr_reader :processing_method
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :provider_id
+    sig { returns(T.nilable(T::Boolean)) }
+    attr_reader :sandbox
+    sig { returns(T.nilable(String)) }
+    attr_reader :service_name
+    sig { returns(T.nilable(T::Boolean)) }
+    attr_reader :supports_network_tokenization
+    sig { returns(T.nilable(String)) }
+    attr_reader :type
+    sig { returns(T.nilable(String)) }
+    attr_reader :updated_at
+
+    class << self
+      sig do
+        params(
+          id: T.any(Integer, String),
+          session: Auth::Session
+        ).returns(T.nilable(PaymentGateway))
+      end
+      def find(
+        id:,
+        session: ShopifyAPI::Context.active_session
+      )
+        result = base_find(
+          session: session,
+          ids: {id: id},
+          params: {},
+        )
+        T.cast(result[0], T.nilable(PaymentGateway))
+      end
+
+      sig do
+        params(
+          id: T.any(Integer, String),
+          session: Auth::Session
+        ).returns(T.untyped)
+      end
+      def delete(
+        id:,
+        session: ShopifyAPI::Context.active_session
+      )
+        request(
+          http_method: :delete,
+          operation: :delete,
+          session: session,
+          ids: {id: id},
+          params: {},
+        )
+      end
+
+      sig do
+        params(
+          session: Auth::Session,
+          kwargs: T.untyped
+        ).returns(T::Array[PaymentGateway])
+      end
+      def all(
+        session: ShopifyAPI::Context.active_session,
+        **kwargs
+      )
+        response = base_find(
+          session: session,
+          ids: {},
+          params: {}.merge(kwargs).compact,
+        )
+
+        T.cast(response, T::Array[PaymentGateway])
+      end
+
+    end
+
+  end
+end

data/lib/shopify_api/rest/resources/2021_10/payment_transaction.rb

@@ -0,0 +1,103 @@
+# typed: false
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class PaymentTransaction < ShopifyAPI::Rest::Base
+    extend T::Sig
+
+    @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
+    def initialize(session: ShopifyAPI::Context.active_session)
+      super(session: session)
+
+      @amount = T.let(nil, T.nilable(String))
+      @currency = T.let(nil, T.nilable(Currency))
+      @fee = T.let(nil, T.nilable(String))
+      @id = T.let(nil, T.nilable(Integer))
+      @net = T.let(nil, T.nilable(String))
+      @payout_id = T.let(nil, T.nilable(Integer))
+      @payout_status = T.let(nil, T.nilable(String))
+      @processed_at = T.let(nil, T.nilable(String))
+      @source_id = T.let(nil, T.nilable(Integer))
+      @source_order_id = T.let(nil, T.nilable(Integer))
+      @source_order_transaction_id = T.let(nil, T.nilable(Integer))
+      @source_type = T.let(nil, T.nilable(String))
+      @test = T.let(nil, T.nilable(T::Boolean))
+      @type = T.let(nil, T.nilable(String))
+    end
+
+    @has_one = T.let({
+      currency: Currency
+    }, T::Hash[Symbol, Class])
+    @has_many = T.let({}, T::Hash[Symbol, Class])
+    @paths = T.let([
+      {http_method: :get, operation: :transactions, ids: [], path: "shopify_payments/balance/transactions.json"}
+    ], T::Array[T::Hash[String, T.any(T::Array[Symbol], String, Symbol)]])
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :amount
+    sig { returns(T.nilable(Currency)) }
+    attr_reader :currency
+    sig { returns(T.nilable(String)) }
+    attr_reader :fee
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :id
+    sig { returns(T.nilable(String)) }
+    attr_reader :net
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :payout_id
+    sig { returns(T.nilable(String)) }
+    attr_reader :payout_status
+    sig { returns(T.nilable(String)) }
+    attr_reader :processed_at
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :source_id
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :source_order_id
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :source_order_transaction_id
+    sig { returns(T.nilable(String)) }
+    attr_reader :source_type
+    sig { returns(T.nilable(T::Boolean)) }
+    attr_reader :test
+    sig { returns(T.nilable(String)) }
+    attr_reader :type
+
+    class << self
+      sig do
+        params(
+          since_id: T.untyped,
+          last_id: T.untyped,
+          test: T.untyped,
+          payout_id: T.untyped,
+          payout_status: T.untyped,
+          session: Auth::Session,
+          kwargs: T.untyped
+        ).returns(T.untyped)
+      end
+      def transactions(
+        since_id: nil,
+        last_id: nil,
+        test: nil,
+        payout_id: nil,
+        payout_status: nil,
+        session: ShopifyAPI::Context.active_session,
+        **kwargs
+      )
+        request(
+          http_method: :get,
+          operation: :transactions,
+          session: session,
+          ids: {},
+          params: {since_id: since_id, last_id: last_id, test: test, payout_id: payout_id, payout_status: payout_status}.merge(kwargs).compact,
+          body: {},
+          entity: nil,
+        )
+      end
+
+    end
+
+  end
+end

data/lib/shopify_api/rest/resources/2021_10/payout.rb

@@ -0,0 +1,93 @@
+# typed: false
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class Payout < ShopifyAPI::Rest::Base
+    extend T::Sig
+
+    @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
+    def initialize(session: ShopifyAPI::Context.active_session)
+      super(session: session)
+
+      @amount = T.let(nil, T.nilable(String))
+      @currency = T.let(nil, T.nilable(String))
+      @date = T.let(nil, T.nilable(String))
+      @id = T.let(nil, T.nilable(Integer))
+      @status = T.let(nil, T.nilable(String))
+    end
+
+    @has_one = T.let({}, T::Hash[Symbol, Class])
+    @has_many = T.let({}, T::Hash[Symbol, Class])
+    @paths = T.let([
+      {http_method: :get, operation: :get, ids: [], path: "shopify_payments/payouts.json"},
+      {http_method: :get, operation: :get, ids: [:id], path: "shopify_payments/payouts/<id>.json"}
+    ], T::Array[T::Hash[String, T.any(T::Array[Symbol], String, Symbol)]])
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :amount
+    sig { returns(T.nilable(String)) }
+    attr_reader :currency
+    sig { returns(T.nilable(String)) }
+    attr_reader :date
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :id
+    sig { returns(T.nilable(String)) }
+    attr_reader :status
+
+    class << self
+      sig do
+        params(
+          id: T.any(Integer, String),
+          session: Auth::Session
+        ).returns(T.nilable(Payout))
+      end
+      def find(
+        id:,
+        session: ShopifyAPI::Context.active_session
+      )
+        result = base_find(
+          session: session,
+          ids: {id: id},
+          params: {},
+        )
+        T.cast(result[0], T.nilable(Payout))
+      end
+
+      sig do
+        params(
+          since_id: T.untyped,
+          last_id: T.untyped,
+          date_min: T.untyped,
+          date_max: T.untyped,
+          date: T.untyped,
+          status: T.untyped,
+          session: Auth::Session,
+          kwargs: T.untyped
+        ).returns(T::Array[Payout])
+      end
+      def all(
+        since_id: nil,
+        last_id: nil,
+        date_min: nil,
+        date_max: nil,
+        date: nil,
+        status: nil,
+        session: ShopifyAPI::Context.active_session,
+        **kwargs
+      )
+        response = base_find(
+          session: session,
+          ids: {},
+          params: {since_id: since_id, last_id: last_id, date_min: date_min, date_max: date_max, date: date, status: status}.merge(kwargs).compact,
+        )
+
+        T.cast(response, T::Array[Payout])
+      end
+
+    end
+
+  end
+end