lunchmoney 0.10.0 → 1.1.0

data/lib/lunchmoney/objects/budget.rb

@@ -0,0 +1,76 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "data"
+require_relative "config"
+
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#budget-object
+    class Budget < LunchMoney::Objects::Object
+      # API object reference documentation: https://lunchmoney.dev/#budget-object
+
+      sig { returns(String) }
+      attr_accessor :category_name
+
+      sig { returns(Integer) }
+      attr_accessor :order
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :category_group_name
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :category_id, :group_id
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :is_group
+
+      sig { returns(T::Boolean) }
+      attr_accessor :is_income, :exclude_from_budget, :exclude_from_totals, :archived
+
+      sig { returns(T::Hash[Symbol, LunchMoney::Objects::Data]) }
+      attr_accessor :data
+
+      sig { returns(T.nilable(T::Hash[Symbol, LunchMoney::Objects::Config])) }
+      attr_accessor :config
+
+      sig { returns(T.nilable({ list: T::Array[LunchMoney::Objects::RecurringExpense] })) }
+      attr_accessor :recurring
+
+      sig do
+        params(
+          is_income: T::Boolean,
+          exclude_from_budget: T::Boolean,
+          exclude_from_totals: T::Boolean,
+          data: T::Hash[Symbol, LunchMoney::Objects::Data],
+          category_name: String,
+          order: Integer,
+          archived: T::Boolean,
+          category_id: T.nilable(Integer),
+          category_group_name: T.nilable(String),
+          group_id: T.nilable(Integer),
+          is_group: T.nilable(T::Boolean),
+          config: T.nilable(T::Hash[Symbol, LunchMoney::Objects::Config]),
+          recurring: T.nilable({ list: T::Array[LunchMoney::Objects::RecurringExpense] }),
+        ).void
+      end
+      def initialize(is_income:, exclude_from_budget:, exclude_from_totals:, data:, category_name:, order:, archived:,
+        category_id: nil, category_group_name: nil, group_id: nil, is_group: nil, config: nil, recurring: nil)
+        super()
+        @category_id = category_id
+        @is_income = is_income
+        @exclude_from_budget = exclude_from_budget
+        @exclude_from_totals = exclude_from_totals
+        @data = data
+        @category_name = category_name
+        @order = order
+        @category_group_name = category_group_name
+        @group_id = group_id
+        @is_group = is_group
+        @config = config
+        @archived = archived
+        @recurring = recurring
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/category.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "child_category"
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#categories-object
+    class Category < ChildCategory
+      sig { returns(T.nilable(String)) }
+      attr_accessor :group_category_name
+
+      sig { returns(T::Boolean) }
+      attr_accessor :is_income, :exclude_from_budget, :exclude_from_totals, :is_group
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :group_id, :order
+
+      sig { returns(T.nilable(T::Array[T.any(LunchMoney::Objects::Category, LunchMoney::Objects::ChildCategory)])) }
+      attr_accessor :children
+
+      sig do
+        params(
+          id: Integer,
+          name: String,
+          is_income: T::Boolean,
+          exclude_from_budget: T::Boolean,
+          exclude_from_totals: T::Boolean,
+          is_group: T::Boolean,
+          archived: T.nilable(T::Boolean),
+          archived_on: T.nilable(String),
+          updated_at: T.nilable(String),
+          created_at: T.nilable(String),
+          group_id: T.nilable(Integer),
+          order: T.nilable(Integer),
+          description: T.nilable(String),
+          children: T.nilable(T::Array[T.any(LunchMoney::Objects::Category, LunchMoney::Objects::ChildCategory)]),
+          group_category_name: T.nilable(String),
+        ).void
+      end
+      def initialize(id:, name:, is_income:, exclude_from_budget:, exclude_from_totals:, is_group:, archived: nil,
+        archived_on: nil, updated_at: nil, created_at: nil, group_id: nil, order: nil, description: nil, children: nil,
+        group_category_name: nil)
+        super(id:, name:, archived:, archived_on:, updated_at:, created_at:, description:)
+        @is_income = is_income
+        @exclude_from_budget = exclude_from_budget
+        @exclude_from_totals = exclude_from_totals
+        @is_group = is_group
+        @group_id = group_id
+        @order = order
+        @children = children
+        @group_category_name = group_category_name
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/child_category.rb

@@ -0,0 +1,44 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LunchMoney
+  module Objects
+    # A slimmed down version of https://lunchmoney.dev/#categories-object used in the
+    # `children` field of some category calls
+    class ChildCategory < LunchMoney::Objects::Object
+      sig { returns(Integer) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description, :archived_on, :updated_at, :created_at
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :archived
+
+      sig do
+        params(
+          id: Integer,
+          name: String,
+          archived: T.nilable(T::Boolean),
+          archived_on: T.nilable(String),
+          updated_at: T.nilable(String),
+          created_at: T.nilable(String),
+          description: T.nilable(String),
+        ).void
+      end
+      def initialize(id:, name:, archived: nil, archived_on: nil, updated_at: nil, created_at: nil, description: nil)
+        super()
+        @id = id
+        @name = name
+        @archived = archived
+        @archived_on = archived_on
+        @updated_at = updated_at
+        @created_at = created_at
+        @description = description
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/child_transaction.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "transaction_base"
+
+module LunchMoney
+  module Objects
+    # Slimmed down version of https://lunchmoney.dev/#transaction-object used in the
+    # `children` field of a transaction object with an additional `formatted_date`` field
+    class ChildTransaction < TransactionBase
+      sig { returns(String) }
+      attr_accessor :formatted_date
+
+      sig do
+        params(
+          id: Integer,
+          date: String,
+          amount: String,
+          currency: String,
+          to_base: Number,
+          payee: String,
+          formatted_date: String,
+          notes: T.nilable(String),
+          asset_id: T.nilable(Integer),
+          plaid_account_id: T.nilable(Integer),
+        ).void
+      end
+      def initialize(id:, date:, amount:, currency:, to_base:, payee:, formatted_date:, notes: nil, asset_id: nil,
+        plaid_account_id: nil)
+        super(id:, date:, amount:, currency:, to_base:, payee:, notes:, asset_id:, plaid_account_id:)
+        @formatted_date = formatted_date
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/config.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#config-object
+    class Config < LunchMoney::Objects::Object
+      # API object reference documentation: https://lunchmoney.dev/#config-object
+
+      sig { returns(Integer) }
+      attr_accessor :config_id
+
+      sig { returns(Number) }
+      attr_accessor :amount, :to_base
+
+      sig { returns(String) }
+      attr_accessor :cadence, :currency, :auto_suggest
+
+      sig do
+        params(
+          config_id: Integer,
+          cadence: String,
+          amount: Number,
+          currency: String,
+          to_base: Number,
+          auto_suggest: String,
+        ).void
+      end
+      def initialize(config_id:, cadence:, amount:, currency:, to_base:, auto_suggest:)
+        super()
+        @config_id = config_id
+        @cadence = cadence
+        @amount = amount
+        @currency = currency
+        @to_base = to_base
+        @auto_suggest = auto_suggest
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/crypto.rb

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "crypto_base"
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#crypto-object
+    class Crypto < CryptoBase
+      include LunchMoney::Validators
+
+      sig { returns(String) }
+      attr_reader :balance_as_of
+
+      sig { returns(String) }
+      attr_accessor :currency, :status
+
+      sig do
+        params(
+          created_at: String,
+          source: String,
+          name: String,
+          balance: String,
+          balance_as_of: String,
+          currency: String,
+          status: String,
+          institution_name: T.nilable(String),
+          id: T.nilable(Integer),
+          zabo_account_id: T.nilable(Integer),
+          display_name: T.nilable(String),
+        ).void
+      end
+      def initialize(created_at:, source:, name:, balance:, balance_as_of:, currency:,
+        status:, institution_name: nil, id: nil, zabo_account_id: nil, display_name: nil)
+        super(created_at:, source:, name:, balance:, institution_name:, id:, zabo_account_id:, display_name:)
+        @balance_as_of = T.let(validate_iso8601!(balance_as_of), String)
+        @currency = currency
+        @status = status
+      end
+
+      sig { params(time: String).void }
+      def balance_as_of=(time)
+        @balance_as_of = validate_iso8601!(time)
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/crypto_base.rb

@@ -0,0 +1,67 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#crypto-object
+    class CryptoBase < LunchMoney::Objects::Object
+      include LunchMoney::Validators
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :id, :zabo_account_id
+
+      sig { returns(String) }
+      attr_reader :source, :created_at
+
+      sig { returns(String) }
+      attr_accessor :name, :balance
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :display_name, :institution_name
+
+      # Valid crypto source types
+      VALID_SOURCES = T.let(
+        [
+          "synced",
+          "manual",
+        ],
+        T::Array[String],
+      )
+
+      sig do
+        params(
+          created_at: String,
+          source: String,
+          name: String,
+          balance: String,
+          institution_name: T.nilable(String),
+          id: T.nilable(Integer),
+          zabo_account_id: T.nilable(Integer),
+          display_name: T.nilable(String),
+        ).void
+      end
+      def initialize(created_at:, source:, name:, balance:, institution_name: nil, id: nil, zabo_account_id: nil,
+        display_name: nil)
+        super()
+        @created_at = T.let(validate_iso8601!(created_at), String)
+        @source = T.let(validate_one_of!(source, VALID_SOURCES), String)
+        @name = name
+        @balance = balance
+        @institution_name = institution_name
+        @id = id
+        @zabo_account_id = zabo_account_id
+        @display_name = display_name
+      end
+
+      sig { params(name: String).void }
+      def source=(name)
+        @source = validate_one_of!(name, VALID_SOURCES)
+      end
+
+      sig { params(time: String).void }
+      def created_at=(time)
+        @created_at = validate_iso8601!(time)
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/data.rb

@@ -0,0 +1,44 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#data-object
+    class Data < LunchMoney::Objects::Object
+      # API object reference documentation: https://lunchmoney.dev/#data-object
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :num_transactions
+
+      sig { returns(T.nilable(Number)) }
+      attr_accessor :budget_amount, :budget_to_base, :spending_to_base
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :budget_currency
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :is_automated
+
+      sig do
+        params(
+          spending_to_base: T.nilable(Number),
+          num_transactions: T.nilable(Integer),
+          budget_amount: T.nilable(Number),
+          budget_currency: T.nilable(String),
+          budget_to_base: T.nilable(Number),
+          is_automated: T.nilable(T::Boolean),
+        ).void
+      end
+      def initialize(spending_to_base: nil, num_transactions: nil, budget_amount: nil, budget_currency: nil,
+        budget_to_base: nil, is_automated: nil)
+        super()
+        @budget_amount = budget_amount
+        @budget_currency = budget_currency
+        @budget_to_base = budget_to_base
+        @spending_to_base = spending_to_base
+        @num_transactions = num_transactions
+        @is_automated = is_automated
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/object.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LunchMoney
+  # Namespace for data objects that represent objects returned from the API
+  module Objects
+    # Base data object for the objects returned and used when calling the LunchMoney API
+    class Object
+      sig { params(symbolize_keys: T::Boolean).returns(T::Hash[String, T.untyped]) }
+      def serialize(symbolize_keys: false)
+        ivars = instance_variables
+
+        output = {}
+
+        ivars.each do |ivar|
+          key = ivar.to_s.gsub("@", "")
+          key = key.to_sym if symbolize_keys
+
+          value = instance_variable_get(ivar)
+
+          output[key] = value
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/plaid_account.rb

@@ -0,0 +1,75 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#plaid-accounts-object
+    class PlaidAccount < LunchMoney::Objects::Object
+      sig { returns(Integer) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :date_linked,
+        :name,
+        :type,
+        :mask,
+        :institution_name,
+        :status,
+        :balance,
+        :currency,
+        :balance_last_update,
+        :display_name,
+        :plaid_last_successful_update
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :subtype, :import_start_date, :last_fetch, :last_import
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :limit
+
+      sig do
+        params(
+          date_linked: String,
+          name: String,
+          type: String,
+          mask: String,
+          institution_name: String,
+          status: String,
+          balance: String,
+          currency: String,
+          balance_last_update: String,
+          display_name: String,
+          id: Integer,
+          plaid_last_successful_update: String,
+          last_import: T.nilable(String),
+          limit: T.nilable(Integer),
+          subtype: T.nilable(String),
+          import_start_date: T.nilable(String),
+          last_fetch: T.nilable(String),
+        ).void
+      end
+      def initialize(date_linked:, name:, type:, mask:, institution_name:, status:, balance:, currency:,
+        balance_last_update:, display_name:, id:, plaid_last_successful_update:, last_import: nil, limit: nil,
+        subtype: nil, import_start_date: nil, last_fetch: nil)
+        super()
+        @id = id
+        @date_linked = date_linked
+        @name = name
+        @display_name = display_name
+        @type = type
+        @subtype = subtype
+        @mask = mask
+        @institution_name = institution_name
+        @status = status
+        @limit = limit
+        @balance = balance
+        @currency = currency
+        @balance_last_update = balance_last_update
+        @import_start_date = import_start_date
+        @last_import = last_import
+        @last_fetch = last_fetch
+        @plaid_last_successful_update = plaid_last_successful_update
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/recurring_expense.rb

@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "recurring_expense_base"
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#recurring-expenses-object
+    class RecurringExpense < RecurringExpenseBase
+      sig { returns(Integer) }
+      attr_accessor :id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :start_date, :end_date, :description, :original_name
+
+      sig { returns(String) }
+      attr_accessor :cadence, :billing_date, :type, :source, :created_at
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :plaid_account_id, :asset_id, :transaction_id, :category_id
+
+      sig do
+        params(
+          cadence: String,
+          payee: String,
+          amount: String,
+          currency: String,
+          billing_date: String,
+          type: String,
+          source: String,
+          id: Integer,
+          created_at: String,
+          category_id: T.nilable(Integer),
+          start_date: T.nilable(String),
+          end_date: T.nilable(String),
+          description: T.nilable(String),
+          original_name: T.nilable(String),
+          plaid_account_id: T.nilable(Integer),
+          asset_id: T.nilable(Integer),
+          transaction_id: T.nilable(Integer),
+          to_base: T.nilable(Number),
+        ).void
+      end
+      def initialize(cadence:, payee:, amount:, currency:, billing_date:, type:, source:, id:, created_at:,
+        category_id: nil, start_date: nil, end_date: nil, description: nil, original_name: nil, plaid_account_id: nil,
+        asset_id: nil, transaction_id: nil, to_base: nil)
+        super(payee:, amount:, currency:, to_base:)
+        @cadence = cadence
+        @payee = payee
+        @amount = amount
+        @currency = currency
+        @billing_date = billing_date
+        @type = type
+        @source = source
+        @id = id
+        @category_id = category_id
+        @created_at = created_at
+        @start_date = start_date
+        @end_date = end_date
+        @description = description
+        @original_name = original_name
+        @plaid_account_id = plaid_account_id
+        @asset_id = asset_id
+        @transaction_id = transaction_id
+        @to_base = to_base
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/recurring_expense_base.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#recurring-expenses-object
+    class RecurringExpenseBase < LunchMoney::Objects::Object
+      sig { returns(String) }
+      attr_accessor :payee, :currency, :amount
+
+      sig { returns(T.nilable(Number)) }
+      attr_accessor :to_base
+
+      sig do
+        params(
+          payee: String,
+          amount: String,
+          currency: String,
+          to_base: T.nilable(Number),
+        ).void
+      end
+      def initialize(payee:, amount:, currency:, to_base:)
+        super()
+        @payee = payee
+        @amount = amount
+        @currency = currency
+        @to_base = to_base
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/split.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "transaction_modification_base"
+
+module LunchMoney
+  module Objects
+    # Object used to split a transaction when updating https://lunchmoney.dev/#update-transaction
+    class Split < TransactionModificationBase
+      sig { returns(T.any(Number, String)) }
+      attr_accessor :amount
+
+      sig do
+        params(
+          amount: T.any(Number, String),
+          payee: T.nilable(String),
+          date: T.nilable(String),
+          category_id: T.nilable(Integer),
+          notes: T.nilable(String),
+        ).void
+      end
+      def initialize(amount:, payee: nil, date: nil, category_id: nil, notes: nil)
+        super(payee:, date:, category_id:, notes:)
+        @amount = amount
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/tag.rb

@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "tag_base"
+
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#tags-object
+    class Tag < TagBase
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      sig { returns(T::Boolean) }
+      attr_accessor :archived
+
+      sig { params(id: Integer, name: String, archived: T::Boolean, description: T.nilable(String)).void }
+      def initialize(id:, name:, archived:, description: nil)
+        super(id:, name:)
+        @archived = archived
+        @description = description
+      end
+    end
+  end
+end

data/lib/lunchmoney/objects/tag_base.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LunchMoney
+  module Objects
+    # https://lunchmoney.dev/#tags-object without some fields. This is used within field returns of other objects like
+    # field returns of other objects like transactions
+    class TagBase < LunchMoney::Objects::Object
+      sig { returns(Integer) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { params(id: Integer, name: String).void }
+      def initialize(id:, name:)
+        super()
+        @id = id
+        @name = name
+      end
+    end
+  end
+end