vitable-connect 0.3.0 → 0.5.0

data/rbi/vitable_connect/models/group.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class Group < VitableConnect::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(VitableConnect::Group, VitableConnect::Internal::AnyHash)
+        end
+
+      # Prefixed group identifier (`grp_<base64-encoded-uuid>`).
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Group creation timestamp (ISO 8601, UTC).
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :created_at
+
+      # Stable identifier for this group in the integrator's own system.
+      sig { returns(String) }
+      attr_accessor :external_reference_id
+
+      # Human-readable group name.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Prefixed organization identifier (`org_<base64-encoded-uuid>`).
+      sig { returns(String) }
+      attr_accessor :organization_id
+
+      # Last-update timestamp (ISO 8601, UTC).
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :updated_at
+
+      sig do
+        params(
+          id: String,
+          created_at: T.nilable(Time),
+          external_reference_id: String,
+          name: String,
+          organization_id: String,
+          updated_at: T.nilable(Time)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Prefixed group identifier (`grp_<base64-encoded-uuid>`).
+        id:,
+        # Group creation timestamp (ISO 8601, UTC).
+        created_at:,
+        # Stable identifier for this group in the integrator's own system.
+        external_reference_id:,
+        # Human-readable group name.
+        name:,
+        # Prefixed organization identifier (`org_<base64-encoded-uuid>`).
+        organization_id:,
+        # Last-update timestamp (ISO 8601, UTC).
+        updated_at:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            created_at: T.nilable(Time),
+            external_reference_id: String,
+            name: String,
+            organization_id: String,
+            updated_at: T.nilable(Time)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/group_create_params.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class GroupCreateParams < VitableConnect::Internal::Type::BaseModel
+      extend VitableConnect::Internal::Type::RequestParameters::Converter
+      include VitableConnect::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::GroupCreateParams,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :external_reference_id
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig do
+        params(
+          external_reference_id: String,
+          name: String,
+          request_options: VitableConnect::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(external_reference_id:, name:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            external_reference_id: String,
+            name: String,
+            request_options: VitableConnect::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/group_list_params.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class GroupListParams < VitableConnect::Internal::Type::BaseModel
+      extend VitableConnect::Internal::Type::RequestParameters::Converter
+      include VitableConnect::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::GroupListParams,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # Items per page (default: 20, max: 100)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Page number (default: 1)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :page
+
+      sig { params(page: Integer).void }
+      attr_writer :page
+
+      sig do
+        params(
+          limit: Integer,
+          page: Integer,
+          request_options: VitableConnect::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Items per page (default: 20, max: 100)
+        limit: nil,
+        # Page number (default: 1)
+        page: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            limit: Integer,
+            page: Integer,
+            request_options: VitableConnect::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/group_response.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class GroupResponse < VitableConnect::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::GroupResponse,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      sig { returns(VitableConnect::Group) }
+      attr_reader :data
+
+      sig { params(data: VitableConnect::Group::OrHash).void }
+      attr_writer :data
+
+      # Response containing a single group resource.
+      sig do
+        params(data: VitableConnect::Group::OrHash).returns(T.attached_class)
+      end
+      def self.new(data:)
+      end
+
+      sig { override.returns({ data: VitableConnect::Group }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/{benefit_eligibility_policy_retrieve_params.rbi → group_retrieve_params.rbi}

@@ -2,38 +2,38 @@
 
 module VitableConnect
   module Models
-    class BenefitEligibilityPolicyRetrieveParams < VitableConnect::Internal::Type::BaseModel
+    class GroupRetrieveParams < VitableConnect::Internal::Type::BaseModel
       extend VitableConnect::Internal::Type::RequestParameters::Converter
       include VitableConnect::Internal::Type::RequestParameters
 
       OrHash =
         T.type_alias do
           T.any(
-            VitableConnect::BenefitEligibilityPolicyRetrieveParams,
+            VitableConnect::GroupRetrieveParams,
             VitableConnect::Internal::AnyHash
           )
         end
 
-      # Unique benefit eligibility policy identifier (epol\_\*)
+      # Unique group identifier (grp\_\*)
       sig { returns(String) }
-      attr_accessor :policy_id
+      attr_accessor :group_id
 
       sig do
         params(
-          policy_id: String,
+          group_id: String,
           request_options: VitableConnect::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
-        # Unique benefit eligibility policy identifier (epol\_\*)
-        policy_id:,
+        # Unique group identifier (grp\_\*)
+        group_id:,
         request_options: {}
       )
       end
 
       sig do
         override.returns(
-          { policy_id: String, request_options: VitableConnect::RequestOptions }
+          { group_id: String, request_options: VitableConnect::RequestOptions }
         )
       end
       def to_hash

data/rbi/vitable_connect/models/group_update_params.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class GroupUpdateParams < VitableConnect::Internal::Type::BaseModel
+      extend VitableConnect::Internal::Type::RequestParameters::Converter
+      include VitableConnect::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::GroupUpdateParams,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # Unique group identifier (grp\_\*)
+      sig { returns(String) }
+      attr_accessor :group_id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_reference_id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :name
+
+      sig do
+        params(
+          group_id: String,
+          external_reference_id: T.nilable(String),
+          name: T.nilable(String),
+          request_options: VitableConnect::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique group identifier (grp\_\*)
+        group_id:,
+        external_reference_id: nil,
+        name: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            group_id: String,
+            external_reference_id: T.nilable(String),
+            name: T.nilable(String),
+            request_options: VitableConnect::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/groups/members/sync_retrieve_params.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    module Groups
+      module Members
+        class SyncRetrieveParams < VitableConnect::Internal::Type::BaseModel
+          extend VitableConnect::Internal::Type::RequestParameters::Converter
+          include VitableConnect::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                VitableConnect::Groups::Members::SyncRetrieveParams,
+                VitableConnect::Internal::AnyHash
+              )
+            end
+
+          # Unique group identifier (grp\_\*)
+          sig { returns(String) }
+          attr_accessor :group_id
+
+          sig { returns(String) }
+          attr_accessor :request_id
+
+          sig do
+            params(
+              group_id: String,
+              request_id: String,
+              request_options: VitableConnect::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Unique group identifier (grp\_\*)
+            group_id:,
+            request_id:,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                group_id: String,
+                request_id: String,
+                request_options: VitableConnect::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/groups/members/sync_retrieve_response.rbi

@@ -0,0 +1,282 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    module Groups
+      module Members
+        class SyncRetrieveResponse < VitableConnect::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                VitableConnect::Models::Groups::Members::SyncRetrieveResponse,
+                VitableConnect::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data
+            )
+          end
+          attr_reader :data
+
+          sig do
+            params(
+              data:
+                VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::OrHash
+            ).void
+          end
+          attr_writer :data
+
+          # Response containing a single group member sync request detail resource.
+          sig do
+            params(
+              data:
+                VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(data:)
+          end
+
+          sig do
+            override.returns(
+              {
+                data:
+                  VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Data < VitableConnect::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data,
+                  VitableConnect::Internal::AnyHash
+                )
+              end
+
+            sig { returns(Time) }
+            attr_accessor :accepted_at
+
+            sig { returns(T.nilable(Time)) }
+            attr_accessor :completed_at
+
+            sig { returns(String) }
+            attr_accessor :group_id
+
+            sig { returns(String) }
+            attr_accessor :request_id
+
+            sig do
+              returns(
+                T.nilable(
+                  VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results
+                )
+              )
+            end
+            attr_reader :results
+
+            sig do
+              params(
+                results:
+                  T.nilable(
+                    VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::OrHash
+                  )
+              ).void
+            end
+            attr_writer :results
+
+            sig do
+              params(
+                accepted_at: Time,
+                completed_at: T.nilable(Time),
+                group_id: String,
+                request_id: String,
+                results:
+                  T.nilable(
+                    VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::OrHash
+                  )
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              accepted_at:,
+              completed_at:,
+              group_id:,
+              request_id:,
+              results:
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  accepted_at: Time,
+                  completed_at: T.nilable(Time),
+                  group_id: String,
+                  request_id: String,
+                  results:
+                    T.nilable(
+                      VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results
+                    )
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class Results < VitableConnect::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results,
+                    VitableConnect::Internal::AnyHash
+                  )
+                end
+
+              sig { returns(T::Array[String]) }
+              attr_accessor :added_group_member_ids
+
+              sig do
+                returns(
+                  T::Array[
+                    VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure
+                  ]
+                )
+              end
+              attr_accessor :failures
+
+              sig { returns(T::Array[String]) }
+              attr_accessor :removed_group_member_ids
+
+              sig do
+                params(
+                  added_group_member_ids: T::Array[String],
+                  failures:
+                    T::Array[
+                      VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure::OrHash
+                    ],
+                  removed_group_member_ids: T::Array[String]
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                added_group_member_ids:,
+                failures:,
+                removed_group_member_ids:
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    added_group_member_ids: T::Array[String],
+                    failures:
+                      T::Array[
+                        VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure
+                      ],
+                    removed_group_member_ids: T::Array[String]
+                  }
+                )
+              end
+              def to_hash
+              end
+
+              class Failure < VitableConnect::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure,
+                      VitableConnect::Internal::AnyHash
+                    )
+                  end
+
+                # - `add` - add
+                # - `remove` - remove
+                sig do
+                  returns(
+                    VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure::Operation::TaggedSymbol
+                  )
+                end
+                attr_accessor :operation
+
+                sig { returns(String) }
+                attr_accessor :reason
+
+                sig { returns(String) }
+                attr_accessor :reference_id
+
+                sig do
+                  params(
+                    operation:
+                      VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure::Operation::OrSymbol,
+                    reason: String,
+                    reference_id: String
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # - `add` - add
+                  # - `remove` - remove
+                  operation:,
+                  reason:,
+                  reference_id:
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      operation:
+                        VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure::Operation::TaggedSymbol,
+                      reason: String,
+                      reference_id: String
+                    }
+                  )
+                end
+                def to_hash
+                end
+
+                # - `add` - add
+                # - `remove` - remove
+                module Operation
+                  extend VitableConnect::Internal::Type::Enum
+
+                  TaggedSymbol =
+                    T.type_alias do
+                      T.all(
+                        Symbol,
+                        VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure::Operation
+                      )
+                    end
+                  OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                  ADD =
+                    T.let(
+                      :add,
+                      VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure::Operation::TaggedSymbol
+                    )
+                  REMOVE =
+                    T.let(
+                      :remove,
+                      VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure::Operation::TaggedSymbol
+                    )
+
+                  sig do
+                    override.returns(
+                      T::Array[
+                        VitableConnect::Models::Groups::Members::SyncRetrieveResponse::Data::Results::Failure::Operation::TaggedSymbol
+                      ]
+                    )
+                  end
+                  def self.values
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end