modern_treasury 0.5.0 → 0.7.0

data/rbi/modern_treasury/models/payment_order.rbi

@@ -11,11 +11,26 @@ module ModernTreasury
       sig { returns(String) }
       attr_accessor :id
 
+      sig { returns(ModernTreasury::PaymentOrder::Accounting) }
+      attr_reader :accounting
+
+      sig do
+        params(
+          accounting: ModernTreasury::PaymentOrder::Accounting::OrHash
+        ).void
+      end
+      attr_writer :accounting
+
       # The ID of one of your accounting categories. Note that these will only be
       # accessible if your accounting system has been connected.
       sig { returns(T.nilable(String)) }
       attr_accessor :accounting_category_id
 
+      # The ID of one of your accounting ledger classes. Note that these will only be
+      # accessible if your accounting system has been connected.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :accounting_ledger_class_id
+
       # Value in specified currency's smallest unit. e.g. $10 would be represented as
       # 1000 (cents). For RTP, the maximum amount allowed by the network is $100,000.
       sig { returns(Integer) }
@@ -43,6 +58,19 @@ module ModernTreasury
       sig { returns(ModernTreasury::Currency::TaggedSymbol) }
       attr_accessor :currency
 
+      # If the payment order's status is `held`, this will include the hold object's
+      # data.
+      sig { returns(T.nilable(ModernTreasury::PaymentOrder::CurrentHold)) }
+      attr_reader :current_hold
+
+      sig do
+        params(
+          current_hold:
+            T.nilable(ModernTreasury::PaymentOrder::CurrentHold::OrHash)
+        ).void
+      end
+      attr_writer :current_hold
+
       # If the payment order's status is `returned`, this will include the return
       # object's data.
       sig { returns(T.nilable(ModernTreasury::ReturnObject)) }
@@ -173,6 +201,14 @@ module ModernTreasury
       end
       attr_accessor :receiving_account_type
 
+      # One of `unreconciled`, `tentatively_reconciled` or `reconciled`.
+      sig do
+        returns(
+          ModernTreasury::PaymentOrder::ReconciliationStatus::TaggedSymbol
+        )
+      end
+      attr_accessor :reconciliation_status
+
       sig { returns(T::Array[ModernTreasury::PaymentOrder::ReferenceNumber]) }
       attr_accessor :reference_numbers
 
@@ -277,13 +313,17 @@ module ModernTreasury
       sig do
         params(
           id: String,
+          accounting: ModernTreasury::PaymentOrder::Accounting::OrHash,
           accounting_category_id: T.nilable(String),
+          accounting_ledger_class_id: T.nilable(String),
           amount: Integer,
           charge_bearer:
             T.nilable(ModernTreasury::PaymentOrder::ChargeBearer::OrSymbol),
           counterparty_id: T.nilable(String),
           created_at: Time,
           currency: ModernTreasury::Currency::OrSymbol,
+          current_hold:
+            T.nilable(ModernTreasury::PaymentOrder::CurrentHold::OrHash),
           current_return: T.nilable(ModernTreasury::ReturnObject::OrHash),
           description: T.nilable(String),
           direction: ModernTreasury::PaymentOrder::Direction::OrSymbol,
@@ -310,6 +350,8 @@ module ModernTreasury
           receiving_account_id: String,
           receiving_account_type:
             ModernTreasury::PaymentOrder::ReceivingAccountType::OrSymbol,
+          reconciliation_status:
+            ModernTreasury::PaymentOrder::ReconciliationStatus::OrSymbol,
           reference_numbers:
             T::Array[ModernTreasury::PaymentOrder::ReferenceNumber::OrHash],
           remittance_information: T.nilable(String),
@@ -342,9 +384,13 @@ module ModernTreasury
       end
       def self.new(
         id:,
+        accounting:,
         # The ID of one of your accounting categories. Note that these will only be
         # accessible if your accounting system has been connected.
         accounting_category_id:,
+        # The ID of one of your accounting ledger classes. Note that these will only be
+        # accessible if your accounting system has been connected.
+        accounting_ledger_class_id:,
         # Value in specified currency's smallest unit. e.g. $10 would be represented as
         # 1000 (cents). For RTP, the maximum amount allowed by the network is $100,000.
         amount:,
@@ -358,6 +404,9 @@ module ModernTreasury
         created_at:,
         # Defaults to the currency of the originating account.
         currency:,
+        # If the payment order's status is `held`, this will include the hold object's
+        # data.
+        current_hold:,
         # If the payment order's status is `returned`, this will include the return
         # object's data.
         current_return:,
@@ -421,6 +470,8 @@ module ModernTreasury
         # The receiving account ID. Can be an `external_account` or `internal_account`.
         receiving_account_id:,
         receiving_account_type:,
+        # One of `unreconciled`, `tentatively_reconciled` or `reconciled`.
+        reconciliation_status:,
         reference_numbers:,
         # For `ach`, this field will be passed through on an addenda record. For `wire`
         # payments the field will be passed through as the "Originator to Beneficiary
@@ -479,7 +530,9 @@ module ModernTreasury
         override.returns(
           {
             id: String,
+            accounting: ModernTreasury::PaymentOrder::Accounting,
             accounting_category_id: T.nilable(String),
+            accounting_ledger_class_id: T.nilable(String),
             amount: Integer,
             charge_bearer:
               T.nilable(
@@ -488,6 +541,7 @@ module ModernTreasury
             counterparty_id: T.nilable(String),
             created_at: Time,
             currency: ModernTreasury::Currency::TaggedSymbol,
+            current_hold: T.nilable(ModernTreasury::PaymentOrder::CurrentHold),
             current_return: T.nilable(ModernTreasury::ReturnObject),
             description: T.nilable(String),
             direction: ModernTreasury::PaymentOrder::Direction::TaggedSymbol,
@@ -514,6 +568,8 @@ module ModernTreasury
             receiving_account_id: String,
             receiving_account_type:
               ModernTreasury::PaymentOrder::ReceivingAccountType::TaggedSymbol,
+            reconciliation_status:
+              ModernTreasury::PaymentOrder::ReconciliationStatus::TaggedSymbol,
             reference_numbers:
               T::Array[ModernTreasury::PaymentOrder::ReferenceNumber],
             remittance_information: T.nilable(String),
@@ -546,6 +602,52 @@ module ModernTreasury
       def to_hash
       end
 
+      class Accounting < ModernTreasury::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModernTreasury::PaymentOrder::Accounting,
+              ModernTreasury::Internal::AnyHash
+            )
+          end
+
+        # The ID of one of your accounting categories. Note that these will only be
+        # accessible if your accounting system has been connected.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :account_id
+
+        # The ID of one of the class objects in your accounting system. Class objects
+        # track segments of your business independent of client or project. Note that
+        # these will only be accessible if your accounting system has been connected.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :class_id
+
+        sig do
+          params(
+            account_id: T.nilable(String),
+            class_id: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The ID of one of your accounting categories. Note that these will only be
+          # accessible if your accounting system has been connected.
+          account_id: nil,
+          # The ID of one of the class objects in your accounting system. Class objects
+          # track segments of your business independent of client or project. Note that
+          # these will only be accessible if your accounting system has been connected.
+          class_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { account_id: T.nilable(String), class_id: T.nilable(String) }
+          )
+        end
+        def to_hash
+        end
+      end
+
       # The party that will pay the fees for the payment order. See
       # https://docs.moderntreasury.com/payments/docs/charge-bearer to understand the
       # differences between the options.
@@ -583,6 +685,235 @@ module ModernTreasury
         end
       end
 
+      class CurrentHold < ModernTreasury::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModernTreasury::PaymentOrder::CurrentHold,
+              ModernTreasury::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(Time) }
+        attr_accessor :created_at
+
+        # The type of object
+        sig do
+          returns(
+            ModernTreasury::PaymentOrder::CurrentHold::Object::TaggedSymbol
+          )
+        end
+        attr_accessor :object
+
+        # The status of the hold
+        sig do
+          returns(
+            ModernTreasury::PaymentOrder::CurrentHold::Status::TaggedSymbol
+          )
+        end
+        attr_accessor :status
+
+        # The ID of the target being held
+        sig { returns(String) }
+        attr_accessor :target_id
+
+        # The type of target being held
+        sig do
+          returns(
+            ModernTreasury::PaymentOrder::CurrentHold::TargetType::TaggedSymbol
+          )
+        end
+        attr_accessor :target_type
+
+        sig { returns(Time) }
+        attr_accessor :updated_at
+
+        # This field will be true if this object exists in the live environment or false
+        # if it exists in the test environment.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :live_mode
+
+        sig { params(live_mode: T::Boolean).void }
+        attr_writer :live_mode
+
+        # Additional metadata for the hold
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_accessor :metadata
+
+        # The reason for the hold
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason
+
+        # The resolution of the hold
+        sig { returns(T.nilable(String)) }
+        attr_accessor :resolution
+
+        # When the hold was resolved
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :resolved_at
+
+        # If the payment order's status is `held`, this will include the hold object's
+        # data.
+        sig do
+          params(
+            id: String,
+            created_at: Time,
+            object: ModernTreasury::PaymentOrder::CurrentHold::Object::OrSymbol,
+            status: ModernTreasury::PaymentOrder::CurrentHold::Status::OrSymbol,
+            target_id: String,
+            target_type:
+              ModernTreasury::PaymentOrder::CurrentHold::TargetType::OrSymbol,
+            updated_at: Time,
+            live_mode: T::Boolean,
+            metadata: T.nilable(T::Hash[Symbol, String]),
+            reason: T.nilable(String),
+            resolution: T.nilable(String),
+            resolved_at: T.nilable(Time)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          created_at:,
+          # The type of object
+          object:,
+          # The status of the hold
+          status:,
+          # The ID of the target being held
+          target_id:,
+          # The type of target being held
+          target_type:,
+          updated_at:,
+          # This field will be true if this object exists in the live environment or false
+          # if it exists in the test environment.
+          live_mode: nil,
+          # Additional metadata for the hold
+          metadata: nil,
+          # The reason for the hold
+          reason: nil,
+          # The resolution of the hold
+          resolution: nil,
+          # When the hold was resolved
+          resolved_at: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              created_at: Time,
+              object:
+                ModernTreasury::PaymentOrder::CurrentHold::Object::TaggedSymbol,
+              status:
+                ModernTreasury::PaymentOrder::CurrentHold::Status::TaggedSymbol,
+              target_id: String,
+              target_type:
+                ModernTreasury::PaymentOrder::CurrentHold::TargetType::TaggedSymbol,
+              updated_at: Time,
+              live_mode: T::Boolean,
+              metadata: T.nilable(T::Hash[Symbol, String]),
+              reason: T.nilable(String),
+              resolution: T.nilable(String),
+              resolved_at: T.nilable(Time)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The type of object
+        module Object
+          extend ModernTreasury::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, ModernTreasury::PaymentOrder::CurrentHold::Object)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          HOLD =
+            T.let(
+              :hold,
+              ModernTreasury::PaymentOrder::CurrentHold::Object::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                ModernTreasury::PaymentOrder::CurrentHold::Object::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # The status of the hold
+        module Status
+          extend ModernTreasury::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, ModernTreasury::PaymentOrder::CurrentHold::Status)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ACTIVE =
+            T.let(
+              :active,
+              ModernTreasury::PaymentOrder::CurrentHold::Status::TaggedSymbol
+            )
+          RESOLVED =
+            T.let(
+              :resolved,
+              ModernTreasury::PaymentOrder::CurrentHold::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                ModernTreasury::PaymentOrder::CurrentHold::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # The type of target being held
+        module TargetType
+          extend ModernTreasury::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                ModernTreasury::PaymentOrder::CurrentHold::TargetType
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          PAYMENT_ORDER =
+            T.let(
+              :payment_order,
+              ModernTreasury::PaymentOrder::CurrentHold::TargetType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                ModernTreasury::PaymentOrder::CurrentHold::TargetType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
       # One of `credit`, `debit`. Describes the direction money is flowing in the
       # transaction. A `credit` moves money from your account to someone else's. A
       # `debit` pulls money from someone else's account to your own. Note that wire,
@@ -702,6 +1033,43 @@ module ModernTreasury
         end
       end
 
+      # One of `unreconciled`, `tentatively_reconciled` or `reconciled`.
+      module ReconciliationStatus
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, ModernTreasury::PaymentOrder::ReconciliationStatus)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        UNRECONCILED =
+          T.let(
+            :unreconciled,
+            ModernTreasury::PaymentOrder::ReconciliationStatus::TaggedSymbol
+          )
+        TENTATIVELY_RECONCILED =
+          T.let(
+            :tentatively_reconciled,
+            ModernTreasury::PaymentOrder::ReconciliationStatus::TaggedSymbol
+          )
+        RECONCILED =
+          T.let(
+            :reconciled,
+            ModernTreasury::PaymentOrder::ReconciliationStatus::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              ModernTreasury::PaymentOrder::ReconciliationStatus::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
       class ReferenceNumber < ModernTreasury::Internal::Type::BaseModel
         OrHash =
           T.type_alias do
@@ -1077,6 +1445,11 @@ module ModernTreasury
               :lob_check_id,
               ModernTreasury::PaymentOrder::ReferenceNumber::ReferenceNumberType::TaggedSymbol
             )
+          MT_FOF_TRANSFER_ID =
+            T.let(
+              :mt_fof_transfer_id,
+              ModernTreasury::PaymentOrder::ReferenceNumber::ReferenceNumberType::TaggedSymbol
+            )
           OTHER =
             T.let(
               :other,
@@ -1268,6 +1641,7 @@ module ModernTreasury
           T.let(:denied, ModernTreasury::PaymentOrder::Status::TaggedSymbol)
         FAILED =
           T.let(:failed, ModernTreasury::PaymentOrder::Status::TaggedSymbol)
+        HELD = T.let(:held, ModernTreasury::PaymentOrder::Status::TaggedSymbol)
         NEEDS_APPROVAL =
           T.let(
             :needs_approval,

data/rbi/modern_treasury/models/payment_order_create_async_params.rbi

@@ -40,11 +40,31 @@ module ModernTreasury
       sig { returns(ModernTreasury::PaymentOrderType::OrSymbol) }
       attr_accessor :type
 
+      sig do
+        returns(
+          T.nilable(ModernTreasury::PaymentOrderCreateAsyncParams::Accounting)
+        )
+      end
+      attr_reader :accounting
+
+      sig do
+        params(
+          accounting:
+            ModernTreasury::PaymentOrderCreateAsyncParams::Accounting::OrHash
+        ).void
+      end
+      attr_writer :accounting
+
       # The ID of one of your accounting categories. Note that these will only be
       # accessible if your accounting system has been connected.
       sig { returns(T.nilable(String)) }
       attr_accessor :accounting_category_id
 
+      # The ID of one of your accounting ledger classes. Note that these will only be
+      # accessible if your accounting system has been connected.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :accounting_ledger_class_id
+
       # The party that will pay the fees for the payment order. See
       # https://docs.moderntreasury.com/payments/docs/charge-bearer to understand the
       # differences between the options.
@@ -249,6 +269,24 @@ module ModernTreasury
       sig { params(receiving_account_id: String).void }
       attr_writer :receiving_account_id
 
+      # One of `unreconciled`, `tentatively_reconciled` or `reconciled`.
+      sig do
+        returns(
+          T.nilable(
+            ModernTreasury::PaymentOrderCreateAsyncParams::ReconciliationStatus::OrSymbol
+          )
+        )
+      end
+      attr_reader :reconciliation_status
+
+      sig do
+        params(
+          reconciliation_status:
+            ModernTreasury::PaymentOrderCreateAsyncParams::ReconciliationStatus::OrSymbol
+        ).void
+      end
+      attr_writer :reconciliation_status
+
       # For `ach`, this field will be passed through on an addenda record. For `wire`
       # payments the field will be passed through as the "Originator to Beneficiary
       # Information", also known as OBI or Fedwire tag 6000.
@@ -307,7 +345,10 @@ module ModernTreasury
             ModernTreasury::PaymentOrderCreateAsyncParams::Direction::OrSymbol,
           originating_account_id: String,
           type: ModernTreasury::PaymentOrderType::OrSymbol,
+          accounting:
+            ModernTreasury::PaymentOrderCreateAsyncParams::Accounting::OrHash,
           accounting_category_id: T.nilable(String),
+          accounting_ledger_class_id: T.nilable(String),
           charge_bearer:
             T.nilable(
               ModernTreasury::PaymentOrderCreateAsyncParams::ChargeBearer::OrSymbol
@@ -340,6 +381,8 @@ module ModernTreasury
           receiving_account:
             ModernTreasury::PaymentOrderCreateAsyncParams::ReceivingAccount::OrHash,
           receiving_account_id: String,
+          reconciliation_status:
+            ModernTreasury::PaymentOrderCreateAsyncParams::ReconciliationStatus::OrSymbol,
           remittance_information: T.nilable(String),
           send_remittance_advice: T.nilable(T::Boolean),
           statement_descriptor: T.nilable(String),
@@ -367,9 +410,13 @@ module ModernTreasury
         # `sepa`, `bacs`, `au_becs`, `interac`, `neft`, `nics`,
         # `nz_national_clearing_code`, `sic`, `signet`, `provexchange`, `zengin`.
         type:,
+        accounting: nil,
         # The ID of one of your accounting categories. Note that these will only be
         # accessible if your accounting system has been connected.
         accounting_category_id: nil,
+        # The ID of one of your accounting ledger classes. Note that these will only be
+        # accessible if your accounting system has been connected.
+        accounting_ledger_class_id: nil,
         # The party that will pay the fees for the payment order. See
         # https://docs.moderntreasury.com/payments/docs/charge-bearer to understand the
         # differences between the options.
@@ -440,6 +487,8 @@ module ModernTreasury
         # `receiving_account_id`, you may pass the id of an external account or an
         # internal account.
         receiving_account_id: nil,
+        # One of `unreconciled`, `tentatively_reconciled` or `reconciled`.
+        reconciliation_status: nil,
         # For `ach`, this field will be passed through on an addenda record. For `wire`
         # payments the field will be passed through as the "Originator to Beneficiary
         # Information", also known as OBI or Fedwire tag 6000.
@@ -482,7 +531,10 @@ module ModernTreasury
               ModernTreasury::PaymentOrderCreateAsyncParams::Direction::OrSymbol,
             originating_account_id: String,
             type: ModernTreasury::PaymentOrderType::OrSymbol,
+            accounting:
+              ModernTreasury::PaymentOrderCreateAsyncParams::Accounting,
             accounting_category_id: T.nilable(String),
+            accounting_ledger_class_id: T.nilable(String),
             charge_bearer:
               T.nilable(
                 ModernTreasury::PaymentOrderCreateAsyncParams::ChargeBearer::OrSymbol
@@ -512,6 +564,8 @@ module ModernTreasury
             receiving_account:
               ModernTreasury::PaymentOrderCreateAsyncParams::ReceivingAccount,
             receiving_account_id: String,
+            reconciliation_status:
+              ModernTreasury::PaymentOrderCreateAsyncParams::ReconciliationStatus::OrSymbol,
             remittance_information: T.nilable(String),
             send_remittance_advice: T.nilable(T::Boolean),
             statement_descriptor: T.nilable(String),
@@ -566,6 +620,52 @@ module ModernTreasury
         end
       end
 
+      class Accounting < ModernTreasury::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModernTreasury::PaymentOrderCreateAsyncParams::Accounting,
+              ModernTreasury::Internal::AnyHash
+            )
+          end
+
+        # The ID of one of your accounting categories. Note that these will only be
+        # accessible if your accounting system has been connected.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :account_id
+
+        # The ID of one of the class objects in your accounting system. Class objects
+        # track segments of your business independent of client or project. Note that
+        # these will only be accessible if your accounting system has been connected.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :class_id
+
+        sig do
+          params(
+            account_id: T.nilable(String),
+            class_id: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The ID of one of your accounting categories. Note that these will only be
+          # accessible if your accounting system has been connected.
+          account_id: nil,
+          # The ID of one of the class objects in your accounting system. Class objects
+          # track segments of your business independent of client or project. Note that
+          # these will only be accessible if your accounting system has been connected.
+          class_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { account_id: T.nilable(String), class_id: T.nilable(String) }
+          )
+        end
+        def to_hash
+        end
+      end
+
       # The party that will pay the fees for the payment order. See
       # https://docs.moderntreasury.com/payments/docs/charge-bearer to understand the
       # differences between the options.
@@ -1605,6 +1705,46 @@ module ModernTreasury
           end
         end
       end
+
+      # One of `unreconciled`, `tentatively_reconciled` or `reconciled`.
+      module ReconciliationStatus
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              ModernTreasury::PaymentOrderCreateAsyncParams::ReconciliationStatus
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        UNRECONCILED =
+          T.let(
+            :unreconciled,
+            ModernTreasury::PaymentOrderCreateAsyncParams::ReconciliationStatus::TaggedSymbol
+          )
+        TENTATIVELY_RECONCILED =
+          T.let(
+            :tentatively_reconciled,
+            ModernTreasury::PaymentOrderCreateAsyncParams::ReconciliationStatus::TaggedSymbol
+          )
+        RECONCILED =
+          T.let(
+            :reconciled,
+            ModernTreasury::PaymentOrderCreateAsyncParams::ReconciliationStatus::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              ModernTreasury::PaymentOrderCreateAsyncParams::ReconciliationStatus::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
     end
   end
 end