treaty 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44bc6d4e290eabdc45efdc7d1e73003f2bb1077e4eee99ad2e9912852d87ecb4
-  data.tar.gz: 72d4767ab3b9e69ec5eec87429cfabd54e6e82783ac4ea321b99eeb04eb85c07
+  metadata.gz: f3115e472c191d30a9c5c8bea6bceb1ed6674437c4e82053817da35e4e94ed4f
+  data.tar.gz: e43b55d9b75c5d2ded71686319a773a814863c10e7d6c25a030151d45883ceeb
 SHA512:
-  metadata.gz: c5d922b7116ebb82cf7d9c60d8bca8c9f45594744cc10e19319f0b3e22d631f8310a1695861f7979f8bf472b87b8bf5687248faae8ca93f90bec04e6fcfa7fd1
-  data.tar.gz: 2fbebe3ceaeeaf1bd743f36fbd40678bda0f9c8dbdbd284610f2de4a0101c6e8d865fa11f555b1fa195fd37e06eae519f82aa08fae8fb29694296ad65fa42be7
+  metadata.gz: f83bdae2ce72bb4f47773ccfa3911be30fb55a5710d211778ce725d487a6b09044c838d18fa23299607ae2ade4cbe671a189ed7d0969b57f1ab7ceaf912c8680
+  data.tar.gz: 01b3769426d4b04b1fe18441c3d943aa36ad8ccca077e7f0d4bf7c5ab1179ec88ae3343c4cd09a9274a87bcf97a88707479458bf7f9fc64fac6936770f0fce06

data/README.md

@@ -13,18 +13,18 @@
 </div>
 
 > [!WARNING]
-> **Development Status**: Treaty is currently under active development in the 0.x version series. Breaking changes may occur between minor versions (0.x) as we refine the API and add new features. The library will stabilize with the 1.0 release. We recommend pinning to specific patch versions in your Gemfile (e.g., `gem "treaty", "~> 0.5.0"`) until the 1.0 release.
+> **Development Status**: Treaty is currently under active development in the 0.x version series. Breaking changes may occur between minor versions (0.x) as we refine the API and add new features. The library will stabilize with the 1.0 release. We recommend pinning to specific patch versions in your Gemfile (e.g., `gem "treaty", "~> 0.9.0"`) until the 1.0 release.
 
 ## 📚 Documentation
 
 Explore comprehensive guides and documentation at [docs](./docs):
 
-- [Getting Started](./docs/getting-started.md) - installation and configuration
-- [Core Concepts](./docs/core-concepts.md) - understand fundamental concepts
-- [API Reference](./docs/api-reference.md) - complete API documentation
-- [Examples](./docs/examples.md) - practical real-world examples
+- [Getting Started](./docs/getting-started.md) - Installation and basic setup
+- [Core Concepts](./docs/core-concepts.md) - Fundamental concepts and architecture
+- [API Reference](./docs/api-reference.md) - Complete API documentation
+- [Examples](./docs/examples.md) - Real-world usage examples
 - [Internationalization](./docs/internationalization.md) - I18n and multilingual support
-- [Full Documentation Index](./docs/README.md) - all documentation topics
+- [Full Documentation Index](./docs/README.md) - Complete documentation index
 
 ## 💡 Why Treaty?
 

data/config/locales/en.yml

@@ -23,6 +23,11 @@ en:
           invalid_schema: "Option 'inclusion' for attribute '%{attribute}' must have a non-empty array of allowed values"
           not_included: "Attribute '%{attribute}' must be one of: %{allowed}. Got: '%{value}'"
 
+        format:
+          type_mismatch: "Option 'format' for attribute '%{attribute}' can only be used with String type. Current type: %{type}"
+          unknown_format: "Unknown format '%{format_name}' for attribute '%{attribute}'. Allowed formats: %{allowed}"
+          mismatch: "Attribute '%{attribute}' has invalid %{format_name} format: '%{value}'"
+
         # Nested structures validation
         nested:
           # Orchestrator errors
@@ -79,7 +84,7 @@ en:
     versioning:
       # Version resolver
       resolver:
-        current_version_required: "Current version is required for validation"
+        specified_version_required: "Specified version is required for validation"
         version_not_found: "Version %{version} not found in treaty definition"
         version_deprecated: "Version %{version} is deprecated and cannot be used"
 

data/lib/treaty/attribute/option/registry_initializer.rb

@@ -21,6 +21,7 @@ module Treaty
       # - `:required` → RequiredValidator - Validates required/optional attributes
       # - `:type` → TypeValidator - Validates value types
       # - `:inclusion` → InclusionValidator - Validates value is in allowed set
+      # - `:format` → FormatValidator - Validates string values match specific formats
       #
       # ## Built-in Modifiers
       #
@@ -71,6 +72,7 @@ module Treaty
             Registry.register(:required, Validators::RequiredValidator, category: :validator)
             Registry.register(:type, Validators::TypeValidator, category: :validator)
             Registry.register(:inclusion, Validators::InclusionValidator, category: :validator)
+            Registry.register(:format, Validators::FormatValidator, category: :validator)
           end
 
           # Registers all built-in modifiers

data/lib/treaty/attribute/option/validators/format_validator.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Option
+      module Validators
+        # Validates that string attribute value matches a specific format.
+        #
+        # ## Supported Formats
+        #
+        # - `:uuid` - Universally unique identifier
+        # - `:email` - Email address (RFC 2822 compliant)
+        # - `:password` - Password (8-16 chars, must contain digit, lowercase, and uppercase)
+        # - `:duration` - ActiveSupport::Duration compatible string (e.g., "1 day", "2 hours")
+        # - `:date` - ISO 8601 date string (e.g., "2025-01-15")
+        # - `:datetime` - ISO 8601 datetime string (e.g., "2025-01-15T10:30:00Z")
+        # - `:time` - Time string (e.g., "10:30:00", "10:30 AM")
+        # - `:boolean` - Boolean string ("true", "false", "0", "1")
+        #
+        # ## Usage Examples
+        #
+        # Simple mode:
+        #   string :email, format: :email
+        #   string :started_on, format: :date
+        #
+        # Advanced mode:
+        #   string :email, format: { is: :email }
+        #   string :started_on, format: { is: :date, message: "Invalid date format" }
+        #   string :started_on, format: { is: :date, message: ->(attribute:, value:, **) { "#{attribute} has invalid date: #{value}" } } # rubocop:disable Layout/LineLength
+        #
+        # ## Validation Rules
+        #
+        # - Only works with `:string` type attributes
+        # - Raises Treaty::Exceptions::Validation if used with non-string types
+        # - Skips validation for nil values (handled by RequiredValidator)
+        # - Each format has a pattern and/or validator for flexible validation
+        #
+        # ## Extensibility
+        #
+        # To add new formats, extend DEFAULT_FORMATS hash with format definition:
+        #   DEFAULT_FORMATS[:custom_format] = {
+        #     pattern: /regex/,
+        #     validator: ->(value) { custom_validation_logic }
+        #   }
+        class FormatValidator < Treaty::Attribute::Option::Base # rubocop:disable Metrics/ClassLength
+          # UUID format regex (8-4-4-4-12 hexadecimal pattern)
+          UUID_PATTERN = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+
+          # Password format regex (8-16 chars, at least one digit, lowercase, and uppercase)
+          PASSWORD_PATTERN = /\A(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).{8,16}\z/
+
+          # Boolean string format regex (accepts "true", "false", "0", "1" case-insensitive)
+          BOOLEAN_PATTERN = /\A(true|false|0|1)\z/i
+
+          # Default format definitions with patterns and validators
+          # Each format can have:
+          # - pattern: Regex for pattern matching
+          # - validator: Lambda for custom validation logic
+          DEFAULT_FORMATS = {
+            uuid: {
+              pattern: UUID_PATTERN,
+              validator: nil
+            },
+            email: {
+              pattern: URI::MailTo::EMAIL_REGEXP,
+              validator: nil
+            },
+            password: {
+              pattern: PASSWORD_PATTERN,
+              validator: nil
+            },
+            duration: {
+              pattern: nil,
+              validator: lambda do |value|
+                ActiveSupport::Duration.parse(value)
+                true
+              rescue StandardError
+                false
+              end
+            },
+            date: {
+              pattern: nil,
+              validator: lambda do |value|
+                Date.parse(value)
+                true
+              rescue ArgumentError, TypeError
+                false
+              end
+            },
+            datetime: {
+              pattern: nil,
+              validator: lambda do |value|
+                DateTime.parse(value)
+                true
+              rescue ArgumentError, TypeError
+                false
+              end
+            },
+            time: {
+              pattern: nil,
+              validator: lambda do |value|
+                Time.parse(value)
+                true
+              rescue ArgumentError, TypeError
+                false
+              end
+            },
+            boolean: {
+              pattern: BOOLEAN_PATTERN,
+              validator: nil
+            }
+          }.freeze
+
+          # Validates that format is only used with string type attributes
+          # and that the format name is valid
+          #
+          # @raise [Treaty::Exceptions::Validation] If format is used with non-string type
+          # @raise [Treaty::Exceptions::Validation] If format name is unknown
+          # @return [void]
+          def validate_schema! # rubocop:disable Metrics/MethodLength
+            # Format option only works with string types
+            unless @attribute_type == :string
+              raise Treaty::Exceptions::Validation,
+                    I18n.t(
+                      "treaty.attributes.validators.format.type_mismatch",
+                      attribute: @attribute_name,
+                      type: @attribute_type
+                    )
+            end
+
+            format_name = option_value
+
+            # Validate that format name exists
+            return if formats.key?(format_name)
+
+            raise Treaty::Exceptions::Validation,
+                  I18n.t(
+                    "treaty.attributes.validators.format.unknown_format",
+                    attribute: @attribute_name,
+                    format_name:,
+                    allowed: formats.keys.join(", ")
+                  )
+          end
+
+          # Validates that the value matches the specified format
+          # Skips validation for nil values (handled by RequiredValidator)
+          #
+          # @param value [String] The value to validate
+          # @raise [Treaty::Exceptions::Validation] If value doesn't match format
+          # @return [void]
+          def validate_value!(value) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+            return if value.nil? # Format validation doesn't check for nil, required does.
+
+            format_name = option_value
+            format_definition = formats[format_name]
+
+            # Allow blank values (empty strings should be caught by required validator)
+            return if value.to_s.strip.empty?
+
+            # Apply pattern matching if defined
+            if format_definition.fetch(:pattern)
+              return if value.match?(format_definition.fetch(:pattern))
+
+              # Pattern failed, and no validator - raise error
+              unless format_definition.fetch(:validator)
+                attributes = {
+                  attribute: @attribute_name,
+                  value:,
+                  format_name:
+                }
+
+                message = resolve_custom_message(**attributes) || default_message(**attributes)
+
+                raise Treaty::Exceptions::Validation, message
+              end
+            end
+
+            # Apply validator if defined
+            return unless format_definition.fetch(:validator)
+            return if format_definition.fetch(:validator).call(value)
+
+            attributes = {
+              attribute: @attribute_name,
+              value:,
+              format_name:
+            }
+
+            message = resolve_custom_message(**attributes) || default_message(**attributes)
+
+            raise Treaty::Exceptions::Validation, message
+          end
+
+          private
+
+          # Returns the available formats (allows for extension)
+          #
+          # @return [Hash] Hash of available formats with their definitions
+          def formats
+            DEFAULT_FORMATS
+          end
+
+          # Generates default error message for format validation failure using I18n
+          #
+          # @param attribute [Symbol] The attribute name
+          # @param value [Object] The actual value that failed validation
+          # @param format_name [Symbol] The format name
+          # @return [String] Default error message
+          def default_message(attribute:, value:, format_name:)
+            I18n.t(
+              "treaty.attributes.validators.format.mismatch",
+              attribute:,
+              value:,
+              format_name:
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treaty/exceptions/base.rb

@@ -35,6 +35,8 @@ module Treaty
     # - Validation - Attribute validation errors
     # - Execution - Service execution errors
     # - Deprecated - API version deprecation
+    # - SpecifiedVersionNotFound - No version specified and no default configured
+    # - VersionNotFound - Requested version doesn't exist
     # - Strategy - Invalid strategy specification
     # - ClassName - Treaty class not found
     # - MethodName - Unknown method in DSL

data/lib/treaty/exceptions/specified_version_not_found.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    # Raised when no API version is specified and no default version is configured
+    #
+    # ## Purpose
+    #
+    # Prevents treaty execution when the client doesn't specify a version
+    # and the treaty hasn't defined a default version to fall back to.
+    # Enforces explicit version selection for API contracts.
+    #
+    # ## Usage
+    #
+    # Raised automatically during version resolution in two scenarios:
+    #
+    # ### Scenario 1: No Version Specified, No Default Configured
+    # ```ruby
+    # class PostsTreaty < ApplicationTreaty
+    #   version 1 do
+    #     # No default: true specified
+    #     request { string :title }
+    #     response(200) { object :post }
+    #   end
+    #
+    #   version 2 do
+    #     request { string :title }
+    #     response(200) { object :post }
+    #   end
+    # end
+    #
+    # # Client request without version header
+    # PostsTreaty.call!(version: nil, params: { title: "Test" })
+    # # => Raises Treaty::Exceptions::SpecifiedVersionNotFound
+    # # => "Specified version is required for validation"
+    # ```
+    #
+    # ### Scenario 2: Empty Version String
+    # ```ruby
+    # PostsTreaty.call!(version: "", params: { title: "Test" })
+    # # => Raises Treaty::Exceptions::SpecifiedVersionNotFound
+    # ```
+    #
+    # ### Prevention: Define Default Version
+    # ```ruby
+    # class PostsTreaty < ApplicationTreaty
+    #   version 1 do
+    #     request { string :title }
+    #     response(200) { object :post }
+    #   end
+    #
+    #   version 2, default: true do  # Marks version 2 as default
+    #     request { string :title }
+    #     response(200) { object :post }
+    #   end
+    # end
+    #
+    # # Now works without explicit version
+    # PostsTreaty.call!(version: nil, params: { title: "Test" })
+    # # => Uses version 2 by default
+    # ```
+    #
+    # ## Integration
+    #
+    # Can be rescued by application controllers to return appropriate HTTP status:
+    #
+    # ```ruby
+    # rescue_from Treaty::Exceptions::SpecifiedVersionNotFound, with: :render_version_required
+    #
+    # def render_version_required(exception)
+    #   render json: {
+    #     error: exception.message,
+    #     hint: "Please specify an API version in the request header"
+    #   }, status: :bad_request  # HTTP 400
+    # end
+    # ```
+    #
+    # ## HTTP Status
+    #
+    # Typically returns HTTP 400 Bad Request, indicating that the client
+    # failed to provide required version information.
+    #
+    # ## Best Practices
+    #
+    # ### For API Providers
+    #
+    # 1. **Always define a default version** for backward compatibility:
+    #    ```ruby
+    #    version 1, default: true do
+    #      # ...
+    #    end
+    #    ```
+    #
+    # 2. **Document version requirements** in API documentation
+    #
+    # 3. **Provide helpful error messages** in rescue handlers
+    #
+    # ### For API Clients
+    #
+    # 1. **Always specify version explicitly** in production code
+    # 2. **Don't rely on default versions** for critical applications
+    # 3. **Handle this exception** with version selection logic
+    #
+    # ## Difference from VersionNotFound
+    #
+    # - **SpecifiedVersionNotFound**: No version specified (nil/blank)
+    # - **VersionNotFound**: Specific version specified but doesn't exist
+    #
+    # ## Version Selection Flow
+    #
+    # 1. Client provides version → Use specified version
+    # 2. Client provides no version → Look for default version
+    # 3. No default version configured → Raise SpecifiedVersionNotFound
+    class SpecifiedVersionNotFound < Base
+    end
+  end
+end

data/lib/treaty/exceptions/version_not_found.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    # Raised when a specific API version is requested but doesn't exist in the treaty
+    #
+    # ## Purpose
+    #
+    # Prevents execution with non-existent API versions. Helps clients
+    # discover available versions and prevents errors from version mismatches.
+    # Ensures API versioning integrity.
+    #
+    # ## Usage
+    #
+    # Raised automatically during version resolution when a requested version
+    # is not defined in the treaty:
+    #
+    # ### Example: Requesting Non-Existent Version
+    # ```ruby
+    # class PostsTreaty < ApplicationTreaty
+    #   version 1 do
+    #     request { string :title }
+    #     response(200) { object :post }
+    #   end
+    #
+    #   version 2, default: true do
+    #     request { string :title, :summary }
+    #     response(200) { object :post }
+    #   end
+    # end
+    #
+    # # Client requests version 3 (doesn't exist)
+    # PostsTreaty.call!(version: "3", params: { title: "Test" })
+    # # => Raises Treaty::Exceptions::VersionNotFound
+    # # => "Version 3 not found in treaty definition"
+    # ```
+    #
+    # ### Example: Version Format Mismatch
+    # ```ruby
+    # # Treaty defines version 1
+    # version 1 do
+    #   # ...
+    # end
+    #
+    # # Client requests "1.0.0" (treated as different from "1")
+    # PostsTreaty.call!(version: "1.0.0", params: {})
+    # # => Raises Treaty::Exceptions::VersionNotFound if exact match not found
+    # ```
+    #
+    # ### Example: Typo in Version Number
+    # ```ruby
+    # PostsTreaty.call!(version: "v2", params: {})  # Should be "2"
+    # # => Raises Treaty::Exceptions::VersionNotFound
+    # ```
+    #
+    # ## Integration
+    #
+    # Can be rescued by application controllers to return appropriate HTTP status:
+    #
+    # ```ruby
+    # rescue_from Treaty::Exceptions::VersionNotFound, with: :render_version_not_found
+    #
+    # def render_version_not_found(exception)
+    #   available_versions = extract_available_versions(exception)
+    #
+    #   render json: {
+    #     error: exception.message,
+    #     available_versions: available_versions,
+    #     hint: "Please use one of the available API versions"
+    #   }, status: :not_found  # HTTP 404
+    # end
+    # ```
+    #
+    # ## HTTP Status
+    #
+    # Typically returns HTTP 404 Not Found, indicating that the requested
+    # resource (API version) does not exist on the server.
+    #
+    # ## Common Scenarios
+    #
+    # ### 1. Client Using Outdated Version Number
+    # ```ruby
+    # # Version 1 was removed, only version 2 and 3 exist
+    # PostsTreaty.call!(version: "1", params: {})
+    # # => VersionNotFound
+    # ```
+    #
+    # ### 2. Client Using Future Version
+    # ```ruby
+    # # Client expects version 5 but only version 1-3 deployed
+    # PostsTreaty.call!(version: "5", params: {})
+    # # => VersionNotFound
+    # ```
+    #
+    # ### 3. Version Format Inconsistency
+    # ```ruby
+    # # Treaty uses integers, client uses semantic versioning
+    # version 1 do ... end
+    # version 2 do ... end
+    #
+    # PostsTreaty.call!(version: "v2.0.0", params: {})
+    # # => VersionNotFound (should use "2")
+    # ```
+    #
+    # ## Best Practices
+    #
+    # ### For API Providers
+    #
+    # 1. **Version numbering consistency**:
+    #    ```ruby
+    #    # Choose one format and stick with it
+    #    version 1 do ... end
+    #    version 2 do ... end
+    #    # OR
+    #    version "1.0.0" do ... end
+    #    version "2.0.0" do ... end
+    #    ```
+    #
+    # 2. **Document available versions** in API documentation
+    #
+    # 3. **Provide version discovery endpoint**:
+    #    ```ruby
+    #    GET /api/versions
+    #    # => { available_versions: ["1", "2", "3"], default: "3" }
+    #    ```
+    #
+    # 4. **Use deprecation** before removal:
+    #    ```ruby
+    #    version 1 do
+    #      deprecated true  # Warn before removing
+    #    end
+    #    ```
+    #
+    # ### For API Clients
+    #
+    # 1. **Validate version before requests**
+    # 2. **Handle version errors gracefully**
+    # 3. **Check API documentation** for available versions
+    # 4. **Implement version fallback logic** when appropriate
+    #
+    # ## Difference from SpecifiedVersionNotFound
+    #
+    # - **SpecifiedVersionNotFound**: No version specified (nil/blank), no default configured
+    # - **VersionNotFound**: Specific version specified but doesn't exist in treaty
+    #
+    # ## Difference from Deprecated
+    #
+    # - **VersionNotFound**: Version doesn't exist at all (HTTP 404)
+    # - **Deprecated**: Version exists but is marked as deprecated (HTTP 410)
+    #
+    # ## Version Resolution Order
+    #
+    # 1. Version specified → Look for exact match
+    # 2. Exact match not found → Raise VersionNotFound
+    # 3. Match found but deprecated → Raise Deprecated
+    # 4. Match found and active → Use version
+    class VersionNotFound < Base
+    end
+  end
+end

data/lib/treaty/version.rb

@@ -3,7 +3,7 @@
 module Treaty
   module VERSION
     MAJOR = 0
-    MINOR = 8
+    MINOR = 10
     PATCH = 0
     PRE = nil
 

data/lib/treaty/versions/resolver.rb

@@ -7,15 +7,15 @@ module Treaty
         new(...).resolve!
       end
 
-      def initialize(current_version:, collection_of_versions:)
-        @current_version = current_version
+      def initialize(specified_version:, collection_of_versions:)
+        @specified_version = specified_version
         @collection_of_versions = collection_of_versions
       end
 
       def resolve!
         determined_factory =
-          if current_version_blank?
-            default_version_factory || raise_current_version_not_found!
+          if specified_version_blank?
+            default_version_factory || raise_specified_version_not_found!
           else
             version_factory || raise_version_not_found!
           end
@@ -30,7 +30,7 @@ module Treaty
       def version_factory
         @version_factory ||=
           @collection_of_versions.find do |factory|
-            factory.version.version == @current_version
+            factory.version.version == @specified_version
           end
       end
 
@@ -39,22 +39,22 @@ module Treaty
           @collection_of_versions.find(&:default_result)
       end
 
-      def current_version_blank?
-        @current_version.to_s.strip.empty?
+      def specified_version_blank?
+        @specified_version.to_s.strip.empty?
       end
 
       ##########################################################################
 
-      def raise_current_version_not_found!
-        raise Treaty::Exceptions::Validation,
-              I18n.t("treaty.versioning.resolver.current_version_required")
+      def raise_specified_version_not_found!
+        raise Treaty::Exceptions::SpecifiedVersionNotFound,
+              I18n.t("treaty.versioning.resolver.specified_version_required")
       end
 
       def raise_version_not_found!
-        raise Treaty::Exceptions::Validation,
+        raise Treaty::Exceptions::VersionNotFound,
               I18n.t(
                 "treaty.versioning.resolver.version_not_found",
-                version: @current_version
+                version: @specified_version
               )
       end
 
@@ -62,7 +62,7 @@ module Treaty
         raise Treaty::Exceptions::Deprecated,
               I18n.t(
                 "treaty.versioning.resolver.version_deprecated",
-                version: @current_version
+                version: @specified_version
               )
       end
     end

data/lib/treaty/versions/workspace.rb

@@ -9,7 +9,7 @@ module Treaty
         super
 
         version_factory = Resolver.resolve!(
-          current_version: version,
+          specified_version: version,
           collection_of_versions: @collection_of_versions
         )
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: treaty
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Anton Sokolov
@@ -159,6 +159,7 @@ files:
 - lib/treaty/attribute/option/modifiers/default_modifier.rb
 - lib/treaty/attribute/option/registry.rb
 - lib/treaty/attribute/option/registry_initializer.rb
+- lib/treaty/attribute/option/validators/format_validator.rb
 - lib/treaty/attribute/option/validators/inclusion_validator.rb
 - lib/treaty/attribute/option/validators/required_validator.rb
 - lib/treaty/attribute/option/validators/type_validator.rb
@@ -185,9 +186,11 @@ files:
 - lib/treaty/exceptions/method_name.rb
 - lib/treaty/exceptions/nested_attributes.rb
 - lib/treaty/exceptions/not_implemented.rb
+- lib/treaty/exceptions/specified_version_not_found.rb
 - lib/treaty/exceptions/strategy.rb
 - lib/treaty/exceptions/unexpected.rb
 - lib/treaty/exceptions/validation.rb
+- lib/treaty/exceptions/version_not_found.rb
 - lib/treaty/info/entity/builder.rb
 - lib/treaty/info/entity/dsl.rb
 - lib/treaty/info/entity/result.rb