phoebe 0.1.0.pre.alpha.1

data/rbi/phoebe/models/product/stat_retrieve_response.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Product
+      class StatRetrieveResponse < Phoebe::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Phoebe::Models::Product::StatRetrieveResponse,
+              Phoebe::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :num_checklists
+
+        sig { params(num_checklists: Integer).void }
+        attr_writer :num_checklists
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :num_contributors
+
+        sig { params(num_contributors: Integer).void }
+        attr_writer :num_contributors
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :num_species
+
+        sig { params(num_species: Integer).void }
+        attr_writer :num_species
+
+        sig do
+          params(
+            num_checklists: Integer,
+            num_contributors: Integer,
+            num_species: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          num_checklists: nil,
+          num_contributors: nil,
+          num_species: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              num_checklists: Integer,
+              num_contributors: Integer,
+              num_species: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/models/product/top100_retrieve_params.rbi

@@ -0,0 +1,122 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Product
+      class Top100RetrieveParams < Phoebe::Internal::Type::BaseModel
+        extend Phoebe::Internal::Type::RequestParameters::Converter
+        include Phoebe::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Phoebe::Product::Top100RetrieveParams,
+              Phoebe::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :region_code
+
+        sig { returns(Integer) }
+        attr_accessor :y_
+
+        sig { returns(Integer) }
+        attr_accessor :m
+
+        # Only fetch this number of contributors.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :max_results
+
+        sig { params(max_results: Integer).void }
+        attr_writer :max_results
+
+        # Order by number of complete checklists (cl) or by number of species seen (spp).
+        sig do
+          returns(
+            T.nilable(Phoebe::Product::Top100RetrieveParams::RankedBy::OrSymbol)
+          )
+        end
+        attr_reader :ranked_by
+
+        sig do
+          params(
+            ranked_by: Phoebe::Product::Top100RetrieveParams::RankedBy::OrSymbol
+          ).void
+        end
+        attr_writer :ranked_by
+
+        sig do
+          params(
+            region_code: String,
+            y_: Integer,
+            m: Integer,
+            max_results: Integer,
+            ranked_by:
+              Phoebe::Product::Top100RetrieveParams::RankedBy::OrSymbol,
+            request_options: Phoebe::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          region_code:,
+          y_:,
+          m:,
+          # Only fetch this number of contributors.
+          max_results: nil,
+          # Order by number of complete checklists (cl) or by number of species seen (spp).
+          ranked_by: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              region_code: String,
+              y_: Integer,
+              m: Integer,
+              max_results: Integer,
+              ranked_by:
+                Phoebe::Product::Top100RetrieveParams::RankedBy::OrSymbol,
+              request_options: Phoebe::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Order by number of complete checklists (cl) or by number of species seen (spp).
+        module RankedBy
+          extend Phoebe::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Phoebe::Product::Top100RetrieveParams::RankedBy)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          SPP =
+            T.let(
+              :spp,
+              Phoebe::Product::Top100RetrieveParams::RankedBy::TaggedSymbol
+            )
+          CL =
+            T.let(
+              :cl,
+              Phoebe::Product::Top100RetrieveParams::RankedBy::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Phoebe::Product::Top100RetrieveParams::RankedBy::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/models/product/top100_retrieve_response.rbi

@@ -0,0 +1,96 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Product
+      class Top100RetrieveResponseItem < Phoebe::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Phoebe::Models::Product::Top100RetrieveResponseItem,
+              Phoebe::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :num_complete_checklists
+
+        sig { params(num_complete_checklists: Integer).void }
+        attr_writer :num_complete_checklists
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :num_species
+
+        sig { params(num_species: Integer).void }
+        attr_writer :num_species
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :profile_handle
+
+        sig { params(profile_handle: String).void }
+        attr_writer :profile_handle
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :row_num
+
+        sig { params(row_num: Integer).void }
+        attr_writer :row_num
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :user_display_name
+
+        sig { params(user_display_name: String).void }
+        attr_writer :user_display_name
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :user_id
+
+        sig { params(user_id: String).void }
+        attr_writer :user_id
+
+        sig do
+          params(
+            num_complete_checklists: Integer,
+            num_species: Integer,
+            profile_handle: String,
+            row_num: Integer,
+            user_display_name: String,
+            user_id: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          num_complete_checklists: nil,
+          num_species: nil,
+          profile_handle: nil,
+          row_num: nil,
+          user_display_name: nil,
+          user_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              num_complete_checklists: Integer,
+              num_species: Integer,
+              profile_handle: String,
+              row_num: Integer,
+              user_display_name: String,
+              user_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      Top100RetrieveResponse =
+        T.let(
+          Phoebe::Internal::Type::ArrayOf[
+            Phoebe::Models::Product::Top100RetrieveResponseItem
+          ],
+          Phoebe::Internal::Type::Converter
+        )
+    end
+  end
+end

data/rbi/phoebe/models/ref/hotspot/geo_retrieve_params.rbi

@@ -0,0 +1,127 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Hotspot
+        class GeoRetrieveParams < Phoebe::Internal::Type::BaseModel
+          extend Phoebe::Internal::Type::RequestParameters::Converter
+          include Phoebe::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Ref::Hotspot::GeoRetrieveParams,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Float) }
+          attr_accessor :lat
+
+          sig { returns(Float) }
+          attr_accessor :lng
+
+          # The number of days back to fetch hotspots.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :back
+
+          sig { params(back: Integer).void }
+          attr_writer :back
+
+          # The search radius from the given position, in kilometers.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :dist
+
+          sig { params(dist: Integer).void }
+          attr_writer :dist
+
+          # Fetch the records in CSV or JSON format.
+          sig do
+            returns(
+              T.nilable(Phoebe::Ref::Hotspot::GeoRetrieveParams::Fmt::OrSymbol)
+            )
+          end
+          attr_reader :fmt
+
+          sig do
+            params(
+              fmt: Phoebe::Ref::Hotspot::GeoRetrieveParams::Fmt::OrSymbol
+            ).void
+          end
+          attr_writer :fmt
+
+          sig do
+            params(
+              lat: Float,
+              lng: Float,
+              back: Integer,
+              dist: Integer,
+              fmt: Phoebe::Ref::Hotspot::GeoRetrieveParams::Fmt::OrSymbol,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            lat:,
+            lng:,
+            # The number of days back to fetch hotspots.
+            back: nil,
+            # The search radius from the given position, in kilometers.
+            dist: nil,
+            # Fetch the records in CSV or JSON format.
+            fmt: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                lat: Float,
+                lng: Float,
+                back: Integer,
+                dist: Integer,
+                fmt: Phoebe::Ref::Hotspot::GeoRetrieveParams::Fmt::OrSymbol,
+                request_options: Phoebe::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Fetch the records in CSV or JSON format.
+          module Fmt
+            extend Phoebe::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, Phoebe::Ref::Hotspot::GeoRetrieveParams::Fmt)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            CSV =
+              T.let(
+                :csv,
+                Phoebe::Ref::Hotspot::GeoRetrieveParams::Fmt::TaggedSymbol
+              )
+            JSON =
+              T.let(
+                :json,
+                Phoebe::Ref::Hotspot::GeoRetrieveParams::Fmt::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Phoebe::Ref::Hotspot::GeoRetrieveParams::Fmt::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/hotspot/geo_retrieve_response.rbi

@@ -0,0 +1,125 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Hotspot
+        class GeoRetrieveResponseItem < Phoebe::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Models::Ref::Hotspot::GeoRetrieveResponseItem,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :country_code
+
+          sig { params(country_code: String).void }
+          attr_writer :country_code
+
+          sig { returns(T.nilable(Float)) }
+          attr_reader :lat
+
+          sig { params(lat: Float).void }
+          attr_writer :lat
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :latest_obs_dt
+
+          sig { params(latest_obs_dt: String).void }
+          attr_writer :latest_obs_dt
+
+          sig { returns(T.nilable(Float)) }
+          attr_reader :lng
+
+          sig { params(lng: Float).void }
+          attr_writer :lng
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :loc_id
+
+          sig { params(loc_id: String).void }
+          attr_writer :loc_id
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :loc_name
+
+          sig { params(loc_name: String).void }
+          attr_writer :loc_name
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :num_species_all_time
+
+          sig { params(num_species_all_time: Integer).void }
+          attr_writer :num_species_all_time
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :subnational1_code
+
+          sig { params(subnational1_code: String).void }
+          attr_writer :subnational1_code
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :subnational2_code
+
+          sig { params(subnational2_code: String).void }
+          attr_writer :subnational2_code
+
+          sig do
+            params(
+              country_code: String,
+              lat: Float,
+              latest_obs_dt: String,
+              lng: Float,
+              loc_id: String,
+              loc_name: String,
+              num_species_all_time: Integer,
+              subnational1_code: String,
+              subnational2_code: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            country_code: nil,
+            lat: nil,
+            latest_obs_dt: nil,
+            lng: nil,
+            loc_id: nil,
+            loc_name: nil,
+            num_species_all_time: nil,
+            subnational1_code: nil,
+            subnational2_code: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                country_code: String,
+                lat: Float,
+                latest_obs_dt: String,
+                lng: Float,
+                loc_id: String,
+                loc_name: String,
+                num_species_all_time: Integer,
+                subnational1_code: String,
+                subnational2_code: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        GeoRetrieveResponse =
+          T.let(
+            Phoebe::Internal::Type::ArrayOf[
+              Phoebe::Models::Ref::Hotspot::GeoRetrieveResponseItem
+            ],
+            Phoebe::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/hotspot/info_retrieve_params.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Hotspot
+        class InfoRetrieveParams < Phoebe::Internal::Type::BaseModel
+          extend Phoebe::Internal::Type::RequestParameters::Converter
+          include Phoebe::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Ref::Hotspot::InfoRetrieveParams,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig do
+            params(request_options: Phoebe::RequestOptions::OrHash).returns(
+              T.attached_class
+            )
+          end
+          def self.new(request_options: {})
+          end
+
+          sig { override.returns({ request_options: Phoebe::RequestOptions }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/hotspot/info_retrieve_response.rbi

@@ -0,0 +1,153 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Hotspot
+        class InfoRetrieveResponse < Phoebe::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Models::Ref::Hotspot::InfoRetrieveResponse,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :country_code
+
+          sig { params(country_code: String).void }
+          attr_writer :country_code
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :country_name
+
+          sig { params(country_name: String).void }
+          attr_writer :country_name
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :hierarchical_name
+
+          sig { params(hierarchical_name: String).void }
+          attr_writer :hierarchical_name
+
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :is_hotspot
+
+          sig { params(is_hotspot: T::Boolean).void }
+          attr_writer :is_hotspot
+
+          sig { returns(T.nilable(Float)) }
+          attr_reader :lat
+
+          sig { params(lat: Float).void }
+          attr_writer :lat
+
+          sig { returns(T.nilable(Float)) }
+          attr_reader :latitude
+
+          sig { params(latitude: Float).void }
+          attr_writer :latitude
+
+          sig { returns(T.nilable(Float)) }
+          attr_reader :lng
+
+          sig { params(lng: Float).void }
+          attr_writer :lng
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :loc_id
+
+          sig { params(loc_id: String).void }
+          attr_writer :loc_id
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :loc_name
+
+          sig { params(loc_name: String).void }
+          attr_writer :loc_name
+
+          sig { returns(T.nilable(Float)) }
+          attr_reader :longitude
+
+          sig { params(longitude: Float).void }
+          attr_writer :longitude
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :name
+
+          sig { params(name: String).void }
+          attr_writer :name
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :subnational1_code
+
+          sig { params(subnational1_code: String).void }
+          attr_writer :subnational1_code
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :subnational1_name
+
+          sig { params(subnational1_name: String).void }
+          attr_writer :subnational1_name
+
+          sig do
+            params(
+              country_code: String,
+              country_name: String,
+              hierarchical_name: String,
+              is_hotspot: T::Boolean,
+              lat: Float,
+              latitude: Float,
+              lng: Float,
+              loc_id: String,
+              loc_name: String,
+              longitude: Float,
+              name: String,
+              subnational1_code: String,
+              subnational1_name: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            country_code: nil,
+            country_name: nil,
+            hierarchical_name: nil,
+            is_hotspot: nil,
+            lat: nil,
+            latitude: nil,
+            lng: nil,
+            loc_id: nil,
+            loc_name: nil,
+            longitude: nil,
+            name: nil,
+            subnational1_code: nil,
+            subnational1_name: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                country_code: String,
+                country_name: String,
+                hierarchical_name: String,
+                is_hotspot: T::Boolean,
+                lat: Float,
+                latitude: Float,
+                lng: Float,
+                loc_id: String,
+                loc_name: String,
+                longitude: Float,
+                name: String,
+                subnational1_code: String,
+                subnational1_name: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end