atlas_engine 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2236db9cf72e66e7bec983fec0ce919b31e1a795e6509ac65e1f914e8cda1c2b
-  data.tar.gz: c4bb6b2c1c8c927abbdf22d66d7a198052ab772f9243ffbd4c02bccced29b4ea
+  metadata.gz: 2ac0ad464ab86fe1db96b5ca3f5a69254d6ad52571d8c83350645c9e031ea58b
+  data.tar.gz: f683950cfa6d89c1cdf4935d8a49d76e416c57220ac29e5aa62adcdaf2a628d5
 SHA512:
-  metadata.gz: a1ccff91cd2b8026fd568ba9aced9688741bf1fd107fd180a83447e9d62ce20750d1ba8d14efe690ab22db6d239dfc1af51edda770c00de31cf07bfc210dc8cf
-  data.tar.gz: 9ee3408a1926463cf05cef4ba3b835e71fb8f490b61033154ac47dc586e2eb8b20fa971c9ca8c23859cec7fd4f7f8e81370f506fdba16e081b6299595a517f05
+  metadata.gz: 79ae2f83d4b4ee2d65a7d6e566bee41ac3b0c5e44f879090b4659151ca9f7987e128badf6f31569530c142ea683b8df6dce10275423469924c44f1477f6480d6
+  data.tar.gz: e1a0e889113742443408d479dba7f1bb294230d4bcfd0af8f128e6c200a19d6c595c1bdf420798ebd2a9cb9caa8fa2cd69ef21ab4361ae066aa6a48861e9f91d

data/README.md

@@ -7,6 +7,7 @@ Atlas Engine is a rails engine that provides a global end-to-end address validat
 * [Local Development Installation](#local-development-installation)
 * [Address Data Ingestion](#address-data-ingestion)
 * [Elasticsearch Matching Strategy](#elasticsearch-matching-strategy)
+* [Hosted Solution](#hosted-solution)
 
 ## Address Validation API
 
@@ -24,7 +25,6 @@ query validation {
       zip: "K2P 2L8"
     }
     locale: "en"
-    matchingStrategy: LOCAL
   ) {
     validationScope
     concerns {
@@ -69,21 +69,6 @@ presence or absence differs per country.
 
 **Locale:** The language in which to render any messages in the validation API response.
 
-**MatchingStrategy:** The strategy used to evaluate the validity of the address input. Out of the box, Atlas Engine
-supports three different matching strategies: `local`, `es`, and `es_street`.
-  - `local` matching uses the [worldwide](https://github.com/Shopify/worldwide) gem to provide the most basic level of
-  address validation. This may include simple errors (required fields not populated) or more advanced errors (province
-  not belonging to the country, zip code not belonging to the province). This level of matching does not require
-  [ingestion](#ingestion) of country data to work, but the level of support and suggestions it can provide in its
-  responses is minimal.
-  - `es` matching uses data indexed in elasticsearch via our [ingestion](#ingestion) process to validate the city,
-  province, country, and zip code fields of the input address, in addition to all of the basic functionality provided
-  in the `local` strategy. A more detailed explanation for how this strategy works can be found [here](#elasticsearch-matching-strategy).
-  - `es_street` is our most advanced matching strategy and requires the highest quality data indexed in elasticsearch
-  via our [ingestion](#ingestion) process. This matching strategy provides everything that `es` and `local` does along
-  with validation of the address1 and address2 components of the address input. A more detailed explanation of how
-  this strategy works can be found [here](#elasticsearch-matching-strategy).
-
 **Validation Scope:** This response object is populated with the field names from the input that have been successfully
 validated.
 
@@ -108,7 +93,6 @@ query validation {
       zip: "90210"
     }
     locale: "en"
-    matchingStrategy: LOCAL
   ) {
     validationScope
     concerns {
@@ -303,23 +287,24 @@ At the moment, `atlas_engine` supports advanced address validation for the follo
 
 | Country/territory | Two-letter code | Locales  | Street | City | Postal Code | Province/State |
 |-------------------|-----------------|----------|--------|------|-------------|----------------|
-| Australia         | AU              |          |        | x    | x           | x              |
-| Austria           | AT              |          |        | x    | x           | x              |
-| Belgium           | BE              | fr,nl,de |        | x    | x           |                |
+| Australia         | AU              |          | x      | x    | x           | x              |
+| Austria           | AT              |          | x      | x    | x           | x              |
+| Belgium           | BE              | fr,nl,de | x      | x    | x           |                |
 | Bermuda           | BM              |          |        | x    | x           | x              |
 | Czechia           | CZ              |          |        | x    | x           |                |
 | Denmark           | DK              |          |        | x    | x           |                |
 | Faroe Islands     | FO              |          |        | x    | x           |                |
-| France            | FR              |          |        | x    | x           |                |
+| France            | FR              |          | x      | x    | x           |                |
+| Gurnsey           | GG              |          |        | x    | x           |                |
 | Italy             | IT              |          |        |      | x           |                |
 | Liechtenstein     | LI              |          |        | x    | x           | x              |
 | Luxembourg        | LU              | fr,lb    |        | x    | x           |                |
-| Netherlands       | NL              | nl       |        | x    | x           | x              |
-| Poland            | PL              |          |        | x    | x           | x              |
+| Netherlands       | NL              | nl       | x      | x    | x           | x              |
+| Poland            | PL              |          | x      | x    | x           | x              |
 | Portugal          | PT              |          |        | x    | x           | x              |
 | Slovenia          | SI              |          |        | x    | x           | x              |
 | South Korea       | KR              |          |        | x    | x           | x              |
-| Switzerland       | CH              | de,fr,it |        | x    | x           |                |
+| Switzerland       | CH              | de,fr,it | x      | x    | x           |                |
 | United States     | US              | en       | x      | x    | x           | x              |
 
 ### Downloading and indexing instructions
@@ -408,6 +393,20 @@ and the US data is in mysql the rest of the process for creating the elasticsear
 
 ## Elasticsearch Matching Strategy
 
+An optional GraphQL parameter, and the strategy used to evaluate the validity of the address input. Out of the box, Atlas Engine
+supports three different matching strategies: `local`, `es`, and `es_street`.
+  - `local` matching uses the [worldwide](https://github.com/Shopify/worldwide) gem to provide the most basic level of
+  address validation. This may include simple errors (required fields not populated) or more advanced errors (province
+  not belonging to the country, zip code not belonging to the province). This level of matching does not require
+  [ingestion](#ingestion) of country data to work, but the level of support and suggestions it can provide in its
+  responses is minimal.
+  - `es` matching uses data indexed in elasticsearch via our [ingestion](#ingestion) process to validate the city,
+  province, country, and zip code fields of the input address, in addition to all of the basic functionality provided
+  in the `local` strategy.
+  - `es_street` is our most advanced matching strategy and requires the highest quality data indexed in elasticsearch
+  via our [ingestion](#ingestion) process. This matching strategy provides everything that `es` and `local` does along
+  with validation of the address1 and address2 components of the address input.
+
 Once we have successfully created and activated an elasticsearch index using open address data, we may now use
 the more advanced elasticsearch matching strategies `es` and `es_street`.
 
@@ -653,3 +652,19 @@ will produce the response:
 ```
 
 This response has no concerns or suggestions, and the input address is therefore considered to be valid.
+
+## Hosted Solution
+
+If you wish to use the Shopify hosted version of the `atlas_engine` codebase in your applications, you will need to [register for an api key](https://address-validation.shopify.dev/#request-api-key) and agree to our [terms and conditions](https://address-validation.shopify.dev/terms-of-service).
+
+Once you have successfully redeemed an api key, you will be able to access the `/graphql` endpoint, which can be queried using this example curl request:
+
+```
+curl --request POST \
+  --url https://atlas-validation.shopifyapps.com/graphql \
+  --header 'Authorization: Bearer {your-api-key}' \
+  --header 'Content-Type: application/json' \
+  --data '{"query":"query validation { validation(address: { address1: \"233 S Wacker Dr\" address2: \"\" city: \"Chicago\" countryCode: US provinceCode: \"IL\" zip: \"60606\" } locale: \"EN\" ) { validationScope concerns { code fieldNames suggestionIds type typeLevel message } suggestions { id address1 address2 city province provinceCode zip } }}","operationName":"validation"}'
+```
+
+Any updates to the `atlas_engine` codebase that are merged into our `main` branch will be deployed to our hosted solution as well.

data/app/countries/atlas_engine/at/country_profile.yml

@@ -9,7 +9,7 @@ ingestion:
   data_mapper: AtlasEngine::AddressValidation::Es::DataMappers::DecompoundingDataMapper
 validation:
   enabled: true
-  default_matching_strategy: es
+  default_matching_strategy: es_street
   has_provinces: true
   address_parser: AtlasEngine::At::ValidationTranscriber::AddressParser
   normalized_components:

data/app/countries/atlas_engine/au/country_profile.yml

@@ -8,6 +8,6 @@ ingestion:
 validation:
   address_parser: AtlasEngine::Au::ValidationTranscriber::AddressParser
   enabled: true
-  default_matching_strategy: es
+  default_matching_strategy: es_street
 open_address:
   filter: AtlasEngine::Au::AddressImporter::OpenAddress::Filter

data/app/countries/atlas_engine/be/country_profile.yml

@@ -5,9 +5,9 @@ ingestion:
     max_zip_edge_ngram: "4"
 validation:
   enabled: true
-  default_matching_strategy: local
+  default_matching_strategy: es_street
   address_parser: AtlasEngine::Be::ValidationTranscriber::AddressParser
-  has_provinces: false 
+  has_provinces: false
   index_locales:
   - fr
   - nl

data/app/countries/atlas_engine/ch/country_profile.yml

@@ -1,7 +1,7 @@
 id: CH
 validation:
   enabled: true
-  default_matching_strategy: local
+  default_matching_strategy: es_street
   has_provinces: false
   address_parser: AtlasEngine::De::ValidationTranscriber::AddressParser
   index_locales:

data/app/countries/atlas_engine/fr/country_profile.yml

@@ -10,6 +10,6 @@ ingestion:
 validation:
   address_parser: AtlasEngine::Fr::ValidationTranscriber::AddressParser
   enabled: true
-  default_matching_strategy: es
+  default_matching_strategy: es_street
   has_provinces: false
   zip_prefix_length: 3

data/app/countries/atlas_engine/nl/country_profile.yml

@@ -7,7 +7,7 @@ ingestion:
 validation:
   enabled: true
   has_provinces: true
-  default_matching_strategy: es
+  default_matching_strategy: es_street
   normalized_components:
   - street_decompounded
   address_parser: AtlasEngine::Nl::ValidationTranscriber::AddressParser

data/app/countries/atlas_engine/pl/country_profile.yml

@@ -7,7 +7,7 @@ ingestion:
 validation:
   address_parser: AtlasEngine::Pl::ValidationTranscriber::AddressParser
   enabled: true
-  default_matching_strategy: es
+  default_matching_strategy: es_street
   exclusions:
     city:
       - AtlasEngine::Pl::AddressValidation::Exclusions::RuralAddress

data/app/countries/atlas_engine/us/country_profile.yml

@@ -9,6 +9,7 @@ ingestion:
 validation:
   enabled: true
   default_matching_strategy: es_street
+  unmatched_components_suggestion_threshold: 1
   address_parser: AtlasEngine::ValidationTranscriber::AddressParserNorthAmerica
 open_address:
   filter: AtlasEngine::Us::AddressImporter::OpenAddress::Filter

data/app/graphql/atlas_engine/schema.graphql

@@ -6,8 +6,12 @@ input AddressInput {
   address2: String
   city: String
   countryCode: ValidationSupportedCountry
+  line2: String
+  neighborhood: String
   phone: String
   provinceCode: String
+  streetName: String
+  streetNumber: String
   zip: String
 }
 
@@ -43,8 +47,13 @@ enum MatchingStrategy {
   LOCAL
 }
 
+enum MessageFormat {
+  INFORMATIVE
+  INSTRUCTIONAL
+}
+
 type Query {
-  validation(address: AddressInput!, locale: String!, matchingStrategy: MatchingStrategy): Validation!
+  validation(address: AddressInput!, locale: String!, matchingStrategy: MatchingStrategy, messageFormat: MessageFormat): Validation!
 }
 
 """
@@ -56,8 +65,12 @@ type Suggestion {
   city: String
   countryCode: ValidationSupportedCountry
   id: String!
+  line2: String
+  neighborhood: String
   province: String
   provinceCode: String
+  streetName: String
+  streetNumber: String
   zip: String
 }
 

data/app/graphql/atlas_engine/types/address_validation/address_input.rb

@@ -12,7 +12,11 @@ module AtlasEngine
         description "Address fields used to fulfill a validation request"
 
         argument :address1, String, required: false
+        argument :street_name, String, required: false
+        argument :street_number, String, required: false
         argument :address2, String, required: false
+        argument :line2, String, required: false
+        argument :neighborhood, String, required: false
         argument :city, String, required: false
         argument :country_code, ValidationSupportedCountry, required: false
         argument :province_code, String, required: false

data/app/graphql/atlas_engine/types/address_validation/concern_type.rb

@@ -1,10 +1,12 @@
-# typed: false
+# typed: true
 # frozen_string_literal: true
 
 module AtlasEngine
   module Types
     module AddressValidation
       class ConcernType < BaseObject
+        extend T::Sig
+
         description "A piece of relevant information regarding the address validation result." \
           "They can be categorized as either a Warning or Error."
 
@@ -14,6 +16,11 @@ module AtlasEngine
         field :type, Enums::ConcernEnum, null: false
         field :type_level, Int, null: false
         field :suggestion_ids, [String], null: false
+
+        sig { returns(T::Array[String]) }
+        def field_names
+          object.field_names.map { |field_name| field_name.to_s.camelize(:lower) }
+        end
       end
     end
   end

data/app/graphql/atlas_engine/types/address_validation/suggestion_type.rb

@@ -9,7 +9,11 @@ module AtlasEngine
 
         field :id, String, null: false
         field :address1, String, null: true
+        field :street_name, String, null: true
+        field :street_number, String, null: true
         field :address2, String, null: true
+        field :line2, String, null: true
+        field :neighborhood, String, null: true
         field :city, String, null: true
         field :zip, String, null: true
         field :province_code, String, null: true

data/app/graphql/atlas_engine/types/message_format_type.rb

@@ -0,0 +1,11 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class MessageFormatType < BaseEnum
+      value :INSTRUCTIONAL, value: "instructional"
+      value :INFORMATIVE, value: "informative"
+    end
+  end
+end

data/app/graphql/atlas_engine/types/query_type.rb

@@ -10,9 +10,10 @@ module AtlasEngine
         argument :address, AddressValidation::AddressInput, required: true
         argument :locale, String, required: true
         argument :matching_strategy, MatchingStrategyType, required: false
+        argument :message_format, MessageFormatType, required: false
       end
 
-      def validation(address:, locale: "en", matching_strategy: nil)
+      def validation(address:, locale: "en", matching_strategy: nil, message_format: nil)
         raise build_graphql_error(AtlasEngine::AddressValidation::Errors::MISSING_PARAMETER) if address.blank?
 
         locale = LocaleFormatHelper.format_locale(locale)
@@ -26,6 +27,7 @@ module AtlasEngine
                 address: address,
                 locale: locale,
                 matching_strategy: matching_strategy,
+                message_format: message_format,
               ),
             )
           end

data/app/lib/atlas_engine/validation_transcriber/address_parsings.rb

@@ -9,22 +9,27 @@ module AtlasEngine
 
       ParsedComponents = T.type_alias { T::Hash[Symbol, String] }
 
-      sig { returns(T::Array[ParsedComponents]) }
-      attr_reader :parsings
-
       sig { params(address_input: AddressValidation::AbstractAddress, locale: T.nilable(String)).void }
       def initialize(address_input:, locale: nil)
-        @parsings = T.let(
+        @address_input = address_input
+        @locale = locale
+      end
+
+      sig { returns(T::Array[ParsedComponents]) }
+      def parsings
+        @parsings ||= T.let(
           begin
-            if address_input.country_code.blank?
+            if @address_input.country_code.blank?
               []
-            else
-              parsing_result = AddressParserFactory.create(address: address_input, locale: locale).parse
-              log_unparsable_address(address_input) if parsing_result.empty?
+            elsif @address_input.street_name.nil? && @address_input.street_number.nil?
+              parsing_result = AddressParserFactory.create(address: @address_input, locale: @locale).parse
+              log_unparsable_address(@address_input) if parsing_result.empty?
               parsing_result
+            else
+              [{ street: @address_input.street_name, building_num: @address_input.street_number }]
             end
           end,
-          T::Array[ParsedComponents],
+          T.nilable(T::Array[ParsedComponents]),
         )
       end
 

data/app/lib/atlas_engine/validation_transcriber/formatter.rb

@@ -22,7 +22,11 @@ module AtlasEngine
       sig do
         params(
           address1: String,
+          street_name: String,
+          street_number: String,
           address2: String,
+          line2: String,
+          neighborhood: String,
           city: String,
           province_code: String,
           zip: String,
@@ -30,10 +34,15 @@ module AtlasEngine
           phone: String,
         ).returns(AddressValidation::Address)
       end
-      def build_address(address1: "", address2: "", city: "", province_code: "", zip: "", country_code: "", phone: "")
+      def build_address(address1: "", street_name: "", street_number: "", address2: "", line2: "", neighborhood: "",
+        city: "", province_code: "", zip: "", country_code: "", phone: "")
         AddressValidation::Address.new(
           address1: address1,
+          street_name: street_name,
+          street_number: street_number,
           address2: address2,
+          line2: line2,
+          neighborhood: neighborhood,
           city: city,
           province_code: province_code,
           zip: zip,

data/app/models/atlas_engine/address_number_range.rb

@@ -164,7 +164,7 @@ module AtlasEngine
 
     sig { params(value: String).returns(T::Boolean) }
     def include_fractions?(value)
-      %r{^([0-9]+ )?([0-9]+/[0-9]+)?$}.match?(value)
+      %r{^([0-9]+ )?([0-9]+/[1-9][0-9]*)?$}.match?(value)
     end
 
     sig { params(str: String).returns(String) }

data/app/models/atlas_engine/address_validation/abstract_address.rb

@@ -13,9 +13,21 @@ module AtlasEngine
       sig { abstract.returns(ComponentType) }
       def address1; end
 
+      sig { returns(ComponentType) }
+      def street_name; end
+
+      sig { returns(ComponentType) }
+      def street_number; end
+
       sig { abstract.returns(ComponentType) }
       def address2; end
 
+      sig { returns(ComponentType) }
+      def line2; end
+
+      sig { returns(ComponentType) }
+      def neighborhood; end
+
       sig { abstract.returns(ComponentType) }
       def city; end
 

data/app/models/atlas_engine/address_validation/address.rb

@@ -13,7 +13,11 @@ module AtlasEngine
       AddressInput = T.type_alias { Types::AddressValidation::AddressInput }
 
       const :address1, ComponentType
+      const :street_name, ComponentType
+      const :street_number, ComponentType
       const :address2, ComponentType
+      const :line2, ComponentType
+      const :neighborhood, ComponentType
       const :city, ComponentType
       const :province_code, ComponentType
       const :phone, ComponentType
@@ -33,7 +37,11 @@ module AtlasEngine
         def from_address(address:)
           new(
             address1: address.address1,
+            street_name: address.street_name,
+            street_number: address.street_number,
             address2: address.address2,
+            line2: address.line2,
+            neighborhood: address.neighborhood,
             city: address.city,
             country_code: address.country_code,
             province_code: address.province_code,

data/app/models/atlas_engine/address_validation/concern_record.rb

@@ -9,9 +9,21 @@ module AtlasEngine
       sig { returns(String) }
       attr_reader :address1
 
+      sig { returns(String) }
+      attr_reader :street_name
+
+      sig { returns(String) }
+      attr_reader :street_number
+
       sig { returns(String) }
       attr_reader :address2
 
+      sig { returns(String) }
+      attr_reader :line2
+
+      sig { returns(String) }
+      attr_reader :neighborhood
+
       sig { returns(String) }
       attr_reader :city
 
@@ -73,7 +85,11 @@ module AtlasEngine
           timestamp: Time,
           origin: String,
           address1: String,
+          street_name: String,
+          street_number: String,
           address2: String,
+          line2: String,
+          neighborhood: String,
           city: String,
           province_code: String,
           country_code: String,
@@ -87,7 +103,11 @@ module AtlasEngine
         timestamp: Time.zone.now,
         origin: "",
         address1: "",
+        street_name: "",
+        street_number: "",
         address2: "",
+        line2: "",
+        neighborhood: "",
         city: "",
         province_code: "",
         country_code: "",
@@ -100,7 +120,11 @@ module AtlasEngine
         @timestamp = timestamp
         @origin = origin
         @address1 = address1
+        @street_name = street_name
+        @street_number = street_number
         @address2 = address2
+        @line2 = line2
+        @neighborhood = neighborhood
         @city = city
         @province_code = province_code
         @country_code = country_code
@@ -114,7 +138,11 @@ module AtlasEngine
       def address_attributes
         {
           address1: address1,
+          street_name: street_name,
+          street_number: street_number,
           address2: address2,
+          line2: line2,
+          neighborhood: neighborhood,
           city: city,
           province_code: province_code,
           zip: zip,

data/app/models/atlas_engine/address_validation/es/validators/full_address.rb

@@ -8,12 +8,13 @@ module AtlasEngine
         class FullAddress < FullAddressValidatorBase
           include LogHelper
 
-          attr_reader :address, :result
+          attr_reader :address, :result, :message_format
 
-          sig { params(address: TAddress, result: Result).void }
-          def initialize(address:, result: Result.new)
+          sig { params(address: TAddress, result: Result, message_format: MessageFormat).void }
+          def initialize(address:, result: Result.new, message_format: MessageFormat::Instructional)
             super
             @matching_strategy = MatchingStrategies::Es
+            @message_format = message_format
           end
 
           sig { override.returns(Result) }
@@ -29,16 +30,23 @@ module AtlasEngine
           sig { returns(AddressValidation::Validators::FullAddress::CandidateResultBase) }
           def build_candidate_result
             unless supported_address?(address)
-              return AddressValidation::Validators::FullAddress::UnsupportedScriptResult.new(address:, result:)
+              return AddressValidation::Validators::FullAddress::UnsupportedScriptResult.new(
+                address:,
+                result:,
+                message_format:,
+              )
             end
 
             if best_candidate.nil?
-              AddressValidation::Validators::FullAddress::NoCandidateResult.new(address:, result:)
+              AddressValidation::Validators::FullAddress::NoCandidateResult.new(
+                address:, result:, message_format:,
+              )
             else
               AddressValidation::Validators::FullAddress::CandidateResult.new(
                 address_comparison: T.must(best_candidate),
                 matching_strategy: @matching_strategy,
                 result: result,
+                message_format:,
               )
             end
           end
@@ -100,6 +108,10 @@ module AtlasEngine
               :zip,
               :address1,
               :address2,
+              :street_name,
+              :street_number,
+              :neighborhood,
+              :line2,
             ])
           end
 
@@ -108,6 +120,7 @@ module AtlasEngine
             result.concerns.flat_map(&:code).intersect?([
               :address1_contains_too_many_words,
               :address2_contains_too_many_words,
+              :street_name_contains_too_many_words,
             ])
           end
 

data/app/models/atlas_engine/address_validation/es/validators/full_address_street.rb

@@ -6,8 +6,8 @@ module AtlasEngine
     module Es
       module Validators
         class FullAddressStreet < FullAddress
-          sig { params(address: TAddress, result: Result).void }
-          def initialize(address:, result: Result.new)
+          sig { params(address: TAddress, message_format: MessageFormat, result: Result).void }
+          def initialize(address:, message_format:, result: Result.new)
             super
             @matching_strategy = MatchingStrategies::EsStreet
           end

data/app/models/atlas_engine/address_validation/full_address_validator_base.rb

@@ -14,10 +14,14 @@ module AtlasEngine
       sig { returns(AbstractAddress) }
       attr_reader :address
 
-      sig { params(address: AbstractAddress, result: Result).void }
-      def initialize(address:, result:)
+      sig { returns(MessageFormat) }
+      attr_reader :message_format
+
+      sig { params(address: AbstractAddress, result: Result, message_format: MessageFormat).void }
+      def initialize(address:, result:, message_format: MessageFormat::Instructional)
         @address = address
         @result = result
+        @message_format = message_format
       end
 
       sig { abstract.returns(Result) }

data/app/models/atlas_engine/address_validation/message_format.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    class MessageFormat < T::Enum
+      enums do
+        Instructional = new("instructional")
+        Informative = new("informative")
+      end
+    end
+  end
+end