phoebe 0.1.0.pre.alpha.1

data/rbi/phoebe/models/ref/taxonomy/ebird_retrieve_params.rbi

@@ -0,0 +1,139 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Taxonomy
+        class EbirdRetrieveParams < Phoebe::Internal::Type::BaseModel
+          extend Phoebe::Internal::Type::RequestParameters::Converter
+          include Phoebe::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Ref::Taxonomy::EbirdRetrieveParams,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          # Only fetch records from these taxonomic categories.
+          sig { returns(T.nilable(String)) }
+          attr_reader :cat
+
+          sig { params(cat: String).void }
+          attr_writer :cat
+
+          # Fetch the records in CSV or JSON format.
+          sig do
+            returns(
+              T.nilable(
+                Phoebe::Ref::Taxonomy::EbirdRetrieveParams::Fmt::OrSymbol
+              )
+            )
+          end
+          attr_reader :fmt
+
+          sig do
+            params(
+              fmt: Phoebe::Ref::Taxonomy::EbirdRetrieveParams::Fmt::OrSymbol
+            ).void
+          end
+          attr_writer :fmt
+
+          # Use this language for common names.
+          sig { returns(T.nilable(String)) }
+          attr_reader :locale
+
+          sig { params(locale: String).void }
+          attr_writer :locale
+
+          # Only fetch records for these species.
+          sig { returns(T.nilable(String)) }
+          attr_reader :species
+
+          sig { params(species: String).void }
+          attr_writer :species
+
+          # Fetch a specific version of the taxonomy.
+          sig { returns(T.nilable(String)) }
+          attr_reader :version
+
+          sig { params(version: String).void }
+          attr_writer :version
+
+          sig do
+            params(
+              cat: String,
+              fmt: Phoebe::Ref::Taxonomy::EbirdRetrieveParams::Fmt::OrSymbol,
+              locale: String,
+              species: String,
+              version: String,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Only fetch records from these taxonomic categories.
+            cat: nil,
+            # Fetch the records in CSV or JSON format.
+            fmt: nil,
+            # Use this language for common names.
+            locale: nil,
+            # Only fetch records for these species.
+            species: nil,
+            # Fetch a specific version of the taxonomy.
+            version: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                cat: String,
+                fmt: Phoebe::Ref::Taxonomy::EbirdRetrieveParams::Fmt::OrSymbol,
+                locale: String,
+                species: String,
+                version: String,
+                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::Taxonomy::EbirdRetrieveParams::Fmt)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            CSV =
+              T.let(
+                :csv,
+                Phoebe::Ref::Taxonomy::EbirdRetrieveParams::Fmt::TaggedSymbol
+              )
+            JSON =
+              T.let(
+                :json,
+                Phoebe::Ref::Taxonomy::EbirdRetrieveParams::Fmt::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Phoebe::Ref::Taxonomy::EbirdRetrieveParams::Fmt::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/taxonomy/ebird_retrieve_response.rbi

@@ -0,0 +1,152 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Taxonomy
+        class EbirdRetrieveResponseItem < Phoebe::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Models::Ref::Taxonomy::EbirdRetrieveResponseItem,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_reader :banding_codes
+
+          sig { params(banding_codes: T::Array[String]).void }
+          attr_writer :banding_codes
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :category
+
+          sig { params(category: String).void }
+          attr_writer :category
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :com_name
+
+          sig { params(com_name: String).void }
+          attr_writer :com_name
+
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_reader :com_name_codes
+
+          sig { params(com_name_codes: T::Array[String]).void }
+          attr_writer :com_name_codes
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :family_code
+
+          sig { params(family_code: String).void }
+          attr_writer :family_code
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :family_com_name
+
+          sig { params(family_com_name: String).void }
+          attr_writer :family_com_name
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :family_sci_name
+
+          sig { params(family_sci_name: String).void }
+          attr_writer :family_sci_name
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :order
+
+          sig { params(order: String).void }
+          attr_writer :order
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :sci_name
+
+          sig { params(sci_name: String).void }
+          attr_writer :sci_name
+
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_reader :sci_name_codes
+
+          sig { params(sci_name_codes: T::Array[String]).void }
+          attr_writer :sci_name_codes
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :species_code
+
+          sig { params(species_code: String).void }
+          attr_writer :species_code
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :taxon_order
+
+          sig { params(taxon_order: Integer).void }
+          attr_writer :taxon_order
+
+          sig do
+            params(
+              banding_codes: T::Array[String],
+              category: String,
+              com_name: String,
+              com_name_codes: T::Array[String],
+              family_code: String,
+              family_com_name: String,
+              family_sci_name: String,
+              order: String,
+              sci_name: String,
+              sci_name_codes: T::Array[String],
+              species_code: String,
+              taxon_order: Integer
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            banding_codes: nil,
+            category: nil,
+            com_name: nil,
+            com_name_codes: nil,
+            family_code: nil,
+            family_com_name: nil,
+            family_sci_name: nil,
+            order: nil,
+            sci_name: nil,
+            sci_name_codes: nil,
+            species_code: nil,
+            taxon_order: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                banding_codes: T::Array[String],
+                category: String,
+                com_name: String,
+                com_name_codes: T::Array[String],
+                family_code: String,
+                family_com_name: String,
+                family_sci_name: String,
+                order: String,
+                sci_name: String,
+                sci_name_codes: T::Array[String],
+                species_code: String,
+                taxon_order: Integer
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        EbirdRetrieveResponse =
+          T.let(
+            Phoebe::Internal::Type::ArrayOf[
+              Phoebe::Models::Ref::Taxonomy::EbirdRetrieveResponseItem
+            ],
+            Phoebe::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/taxonomy/form_list_params.rbi

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

@@ -0,0 +1,15 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Taxonomy
+        FormListResponse =
+          T.let(
+            Phoebe::Internal::Type::ArrayOf[String],
+            Phoebe::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/taxonomy/locale_list_params.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Taxonomy
+        class LocaleListParams < Phoebe::Internal::Type::BaseModel
+          extend Phoebe::Internal::Type::RequestParameters::Converter
+          include Phoebe::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Ref::Taxonomy::LocaleListParams,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :accept_language
+
+          sig { params(accept_language: String).void }
+          attr_writer :accept_language
+
+          sig do
+            params(
+              accept_language: String,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(accept_language: nil, request_options: {})
+          end
+
+          sig do
+            override.returns(
+              {
+                accept_language: String,
+                request_options: Phoebe::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/taxonomy/locale_list_response.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Taxonomy
+        class LocaleListResponseItem < Phoebe::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Models::Ref::Taxonomy::LocaleListResponseItem,
+                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 :last_updated
+
+          sig { params(last_updated: String).void }
+          attr_writer :last_updated
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :name
+
+          sig { params(name: String).void }
+          attr_writer :name
+
+          sig do
+            params(code: String, last_updated: String, name: String).returns(
+              T.attached_class
+            )
+          end
+          def self.new(code: nil, last_updated: nil, name: nil)
+          end
+
+          sig do
+            override.returns(
+              { code: String, last_updated: String, name: String }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        LocaleListResponse =
+          T.let(
+            Phoebe::Internal::Type::ArrayOf[
+              Phoebe::Models::Ref::Taxonomy::LocaleListResponseItem
+            ],
+            Phoebe::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/taxonomy/species_group_list_params.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Taxonomy
+        class SpeciesGroupListParams < Phoebe::Internal::Type::BaseModel
+          extend Phoebe::Internal::Type::RequestParameters::Converter
+          include Phoebe::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Ref::Taxonomy::SpeciesGroupListParams,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          # Locale for species group names. English names are returned for any non-listed
+          # locale or any non-translated group name.
+          sig { returns(T.nilable(String)) }
+          attr_reader :group_name_locale
+
+          sig { params(group_name_locale: String).void }
+          attr_writer :group_name_locale
+
+          sig do
+            params(
+              group_name_locale: String,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Locale for species group names. English names are returned for any non-listed
+            # locale or any non-translated group name.
+            group_name_locale: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                group_name_locale: String,
+                request_options: Phoebe::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # The order in which groups are returned.
+          module SpeciesGrouping
+            extend Phoebe::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Phoebe::Ref::Taxonomy::SpeciesGroupListParams::SpeciesGrouping
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            MERLIN =
+              T.let(
+                :merlin,
+                Phoebe::Ref::Taxonomy::SpeciesGroupListParams::SpeciesGrouping::TaggedSymbol
+              )
+            EBIRD =
+              T.let(
+                :ebird,
+                Phoebe::Ref::Taxonomy::SpeciesGroupListParams::SpeciesGrouping::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Phoebe::Ref::Taxonomy::SpeciesGroupListParams::SpeciesGrouping::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/taxonomy/species_group_list_response.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Taxonomy
+        class SpeciesGroupListResponseItem < Phoebe::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Models::Ref::Taxonomy::SpeciesGroupListResponseItem,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :group_name
+
+          sig { params(group_name: String).void }
+          attr_writer :group_name
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :group_order
+
+          sig { params(group_order: Integer).void }
+          attr_writer :group_order
+
+          sig { returns(T.nilable(T::Array[T::Array[Float]])) }
+          attr_reader :taxon_order_bounds
+
+          sig { params(taxon_order_bounds: T::Array[T::Array[Float]]).void }
+          attr_writer :taxon_order_bounds
+
+          sig do
+            params(
+              group_name: String,
+              group_order: Integer,
+              taxon_order_bounds: T::Array[T::Array[Float]]
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            group_name: nil,
+            group_order: nil,
+            taxon_order_bounds: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                group_name: String,
+                group_order: Integer,
+                taxon_order_bounds: T::Array[T::Array[Float]]
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        SpeciesGroupListResponse =
+          T.let(
+            Phoebe::Internal::Type::ArrayOf[
+              Phoebe::Models::Ref::Taxonomy::SpeciesGroupListResponseItem
+            ],
+            Phoebe::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end

data/rbi/phoebe/models/ref/taxonomy/version_list_params.rbi

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

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Phoebe
+  module Models
+    module Ref
+      module Taxonomy
+        class VersionListResponseItem < Phoebe::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Phoebe::Models::Ref::Taxonomy::VersionListResponseItem,
+                Phoebe::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(Float)) }
+          attr_reader :authority_ver
+
+          sig { params(authority_ver: Float).void }
+          attr_writer :authority_ver
+
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :latest
+
+          sig { params(latest: T::Boolean).void }
+          attr_writer :latest
+
+          sig do
+            params(authority_ver: Float, latest: T::Boolean).returns(
+              T.attached_class
+            )
+          end
+          def self.new(authority_ver: nil, latest: nil)
+          end
+
+          sig { override.returns({ authority_ver: Float, latest: T::Boolean }) }
+          def to_hash
+          end
+        end
+
+        VersionListResponse =
+          T.let(
+            Phoebe::Internal::Type::ArrayOf[
+              Phoebe::Models::Ref::Taxonomy::VersionListResponseItem
+            ],
+            Phoebe::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end

data/rbi/phoebe/models.rbi

@@ -0,0 +1,9 @@
+# typed: strong
+
+module Phoebe
+  Data = Phoebe::Models::Data
+
+  Product = Phoebe::Models::Product
+
+  Ref = Phoebe::Models::Ref
+end