phoebe 0.1.0.pre.alpha.1

data/rbi/phoebe/models/ref/hotspot_list_params.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      class HotspotListParams < Phoebe::Internal::Type::BaseModel
+        extend Phoebe::Internal::Type::RequestParameters::Converter
+        include Phoebe::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Phoebe::Ref::HotspotListParams, Phoebe::Internal::AnyHash)
+          end
+
+        # The number of days back to fetch hotspots.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :back
+
+        sig { params(back: Integer).void }
+        attr_writer :back
+
+        # Fetch the records in CSV or JSON format.
+        sig do
+          returns(T.nilable(Phoebe::Ref::HotspotListParams::Fmt::OrSymbol))
+        end
+        attr_reader :fmt
+
+        sig { params(fmt: Phoebe::Ref::HotspotListParams::Fmt::OrSymbol).void }
+        attr_writer :fmt
+
+        sig do
+          params(
+            back: Integer,
+            fmt: Phoebe::Ref::HotspotListParams::Fmt::OrSymbol,
+            request_options: Phoebe::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The number of days back to fetch hotspots.
+          back: nil,
+          # Fetch the records in CSV or JSON format.
+          fmt: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              back: Integer,
+              fmt: Phoebe::Ref::HotspotListParams::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 { T.all(Symbol, Phoebe::Ref::HotspotListParams::Fmt) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          CSV = T.let(:csv, Phoebe::Ref::HotspotListParams::Fmt::TaggedSymbol)
+          JSON = T.let(:json, Phoebe::Ref::HotspotListParams::Fmt::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Phoebe::Ref::HotspotListParams::Fmt::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/hotspot_list_response.rbi

@@ -0,0 +1,123 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      class HotspotListResponseItem < Phoebe::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Phoebe::Models::Ref::HotspotListResponseItem,
+              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
+
+      HotspotListResponse =
+        T.let(
+          Phoebe::Internal::Type::ArrayOf[
+            Phoebe::Models::Ref::HotspotListResponseItem
+          ],
+          Phoebe::Internal::Type::Converter
+        )
+    end
+  end
+end

data/rbi/phoebe/models/ref/region/adjacent_list_params.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Region
+        class AdjacentListParams < Phoebe::Internal::Type::BaseModel
+          extend Phoebe::Internal::Type::RequestParameters::Converter
+          include Phoebe::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Ref::Region::AdjacentListParams,
+                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/region/adjacent_list_response.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Region
+        class AdjacentListResponseItem < Phoebe::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Models::Ref::Region::AdjacentListResponseItem,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :code
+
+          sig { params(code: String).void }
+          attr_writer :code
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :name
+
+          sig { params(name: String).void }
+          attr_writer :name
+
+          sig { params(code: String, name: String).returns(T.attached_class) }
+          def self.new(code: nil, name: nil)
+          end
+
+          sig { override.returns({ code: String, name: String }) }
+          def to_hash
+          end
+        end
+
+        AdjacentListResponse =
+          T.let(
+            Phoebe::Internal::Type::ArrayOf[
+              Phoebe::Models::Ref::Region::AdjacentListResponseItem
+            ],
+            Phoebe::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Region
+        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::Region::InfoRetrieveParams,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          # The characters used to separate elements in the name.
+          sig { returns(T.nilable(String)) }
+          attr_reader :delim
+
+          sig { params(delim: String).void }
+          attr_writer :delim
+
+          # Control how the name is displayed.
+          sig do
+            returns(
+              T.nilable(
+                Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::OrSymbol
+              )
+            )
+          end
+          attr_reader :region_name_format
+
+          sig do
+            params(
+              region_name_format:
+                Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::OrSymbol
+            ).void
+          end
+          attr_writer :region_name_format
+
+          sig do
+            params(
+              delim: String,
+              region_name_format:
+                Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::OrSymbol,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The characters used to separate elements in the name.
+            delim: nil,
+            # Control how the name is displayed.
+            region_name_format: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                delim: String,
+                region_name_format:
+                  Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::OrSymbol,
+                request_options: Phoebe::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Control how the name is displayed.
+          module RegionNameFormat
+            extend Phoebe::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            DETAILED =
+              T.let(
+                :detailed,
+                Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::TaggedSymbol
+              )
+            DETAILEDNOQUAL =
+              T.let(
+                :detailednoqual,
+                Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::TaggedSymbol
+              )
+            FULL =
+              T.let(
+                :full,
+                Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::TaggedSymbol
+              )
+            NAMEQUAL =
+              T.let(
+                :namequal,
+                Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::TaggedSymbol
+              )
+            NAMEONLY =
+              T.let(
+                :nameonly,
+                Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::TaggedSymbol
+              )
+            REVDETAILED =
+              T.let(
+                :revdetailed,
+                Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Region
+        class InfoRetrieveResponse < Phoebe::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Models::Ref::Region::InfoRetrieveResponse,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              T.nilable(
+                Phoebe::Models::Ref::Region::InfoRetrieveResponse::Bounds
+              )
+            )
+          end
+          attr_reader :bounds
+
+          sig do
+            params(
+              bounds:
+                Phoebe::Models::Ref::Region::InfoRetrieveResponse::Bounds::OrHash
+            ).void
+          end
+          attr_writer :bounds
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :result
+
+          sig { params(result: String).void }
+          attr_writer :result
+
+          sig do
+            params(
+              bounds:
+                Phoebe::Models::Ref::Region::InfoRetrieveResponse::Bounds::OrHash,
+              result: String
+            ).returns(T.attached_class)
+          end
+          def self.new(bounds: nil, result: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                bounds:
+                  Phoebe::Models::Ref::Region::InfoRetrieveResponse::Bounds,
+                result: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Bounds < Phoebe::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Phoebe::Models::Ref::Region::InfoRetrieveResponse::Bounds,
+                  Phoebe::Internal::AnyHash
+                )
+              end
+
+            sig { returns(T.nilable(Float)) }
+            attr_reader :max_x
+
+            sig { params(max_x: Float).void }
+            attr_writer :max_x
+
+            sig { returns(T.nilable(Float)) }
+            attr_reader :max_y
+
+            sig { params(max_y: Float).void }
+            attr_writer :max_y
+
+            sig { returns(T.nilable(Float)) }
+            attr_reader :min_x
+
+            sig { params(min_x: Float).void }
+            attr_writer :min_x
+
+            sig { returns(T.nilable(Float)) }
+            attr_reader :min_y
+
+            sig { params(min_y: Float).void }
+            attr_writer :min_y
+
+            sig do
+              params(
+                max_x: Float,
+                max_y: Float,
+                min_x: Float,
+                min_y: Float
+              ).returns(T.attached_class)
+            end
+            def self.new(max_x: nil, max_y: nil, min_x: nil, min_y: nil)
+            end
+
+            sig do
+              override.returns(
+                { max_x: Float, max_y: Float, min_x: Float, min_y: Float }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/region/list_list_params.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Region
+        class ListListParams < Phoebe::Internal::Type::BaseModel
+          extend Phoebe::Internal::Type::RequestParameters::Converter
+          include Phoebe::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Ref::Region::ListListParams,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :region_type
+
+          # Fetch the records in CSV or JSON format.
+          sig do
+            returns(
+              T.nilable(Phoebe::Ref::Region::ListListParams::Fmt::OrSymbol)
+            )
+          end
+          attr_reader :fmt
+
+          sig do
+            params(fmt: Phoebe::Ref::Region::ListListParams::Fmt::OrSymbol).void
+          end
+          attr_writer :fmt
+
+          sig do
+            params(
+              region_type: String,
+              fmt: Phoebe::Ref::Region::ListListParams::Fmt::OrSymbol,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            region_type:,
+            # Fetch the records in CSV or JSON format.
+            fmt: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                region_type: String,
+                fmt: Phoebe::Ref::Region::ListListParams::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::Region::ListListParams::Fmt)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            CSV =
+              T.let(
+                :csv,
+                Phoebe::Ref::Region::ListListParams::Fmt::TaggedSymbol
+              )
+            JSON =
+              T.let(
+                :json,
+                Phoebe::Ref::Region::ListListParams::Fmt::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[Phoebe::Ref::Region::ListListParams::Fmt::TaggedSymbol]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/region/list_list_response.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Region
+        class ListListResponseItem < Phoebe::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Models::Ref::Region::ListListResponseItem,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :code
+
+          sig { params(code: String).void }
+          attr_writer :code
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :name
+
+          sig { params(name: String).void }
+          attr_writer :name
+
+          sig { params(code: String, name: String).returns(T.attached_class) }
+          def self.new(code: nil, name: nil)
+          end
+
+          sig { override.returns({ code: String, name: String }) }
+          def to_hash
+          end
+        end
+
+        ListListResponse =
+          T.let(
+            Phoebe::Internal::Type::ArrayOf[
+              Phoebe::Models::Ref::Region::ListListResponseItem
+            ],
+            Phoebe::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end