From a21e7803803b271313e0188f177bf03881900ab6 Mon Sep 17 00:00:00 2001
From: Greg Nazario <greg@gnazar.io>
Date: Wed, 28 Aug 2024 09:30:27 -0700
Subject: [PATCH] [spec] Add Behave (cucumber) specifications to python (#25)

* [spec] Add Behave (cucumber) specifications to python

* [behave] Add behave to build dependencies

* [behave] Add stubs to let linting of specs

* [ci] Run behave in normal unit testing
---
 CHANGELOG.md                                  |   2 +
 Makefile                                      |  14 +-
 aptos_sdk/bcs.py                              |   2 +-
 features/account_address.feature              |  68 +++++
 features/bcs_deserialization.feature          | 268 ++++++++++++++++++
 features/bcs_serialization.feature            | 224 +++++++++++++++
 features/steps/account_address.py             |  34 +++
 features/steps/bcs.py                         | 172 +++++++++++
 features/steps/common.py                      | 116 ++++++++
 features/stubs/behave/__init__.pyi            |  32 +++
 features/stubs/behave/_stepimport.pyi         |  38 +++
 features/stubs/behave/_types.pyi              |  25 ++
 features/stubs/behave/api/__init__.pyi        |   0
 features/stubs/behave/api/async_step.pyi      |  33 +++
 features/stubs/behave/capture.pyi             |  45 +++
 features/stubs/behave/compat/__init__.pyi     |   0
 features/stubs/behave/compat/collections.pyi  |   2 +
 features/stubs/behave/configuration.pyi       | 102 +++++++
 features/stubs/behave/contrib/__init__.pyi    |   0
 .../contrib/formatter_missing_steps.pyi       |  19 ++
 .../behave/contrib/scenario_autoretry.pyi     |   3 +
 .../stubs/behave/contrib/steps/__init__.pyi   |   1 +
 .../stubs/behave/contrib/substep_dirs.pyi     |   0
 features/stubs/behave/fixture.pyi             |  16 ++
 features/stubs/behave/formatter/__init__.pyi  |   0
 features/stubs/behave/formatter/_builtins.pyi |   1 +
 features/stubs/behave/formatter/_registry.pyi |  16 ++
 .../stubs/behave/formatter/ansi_escapes.pyi   |  12 +
 features/stubs/behave/formatter/base.pyi      |  42 +++
 .../stubs/behave/formatter/formatters.pyi     |   4 +
 features/stubs/behave/formatter/json.pyi      |  44 +++
 features/stubs/behave/formatter/null.pyi      |   5 +
 features/stubs/behave/formatter/plain.pyi     |  41 +++
 features/stubs/behave/formatter/pretty.pyi    |  62 ++++
 features/stubs/behave/formatter/progress.pyi  |  53 ++++
 features/stubs/behave/formatter/rerun.pyi     |  18 ++
 .../stubs/behave/formatter/sphinx_steps.pyi   |  74 +++++
 .../stubs/behave/formatter/sphinx_util.pyi    |  28 ++
 features/stubs/behave/formatter/steps.pyi     |  77 +++++
 features/stubs/behave/formatter/tags.pyi      |  33 +++
 features/stubs/behave/i18n.pyi                |   3 +
 features/stubs/behave/importer.pyi            |  20 ++
 features/stubs/behave/json_parser.pyi         |  22 ++
 features/stubs/behave/log_capture.pyi         |  29 ++
 features/stubs/behave/matchers.pyi            |  82 ++++++
 features/stubs/behave/model.pyi               | 252 ++++++++++++++++
 features/stubs/behave/model_core.pyi          |  97 +++++++
 features/stubs/behave/model_describe.pyi      |  17 ++
 features/stubs/behave/parser.pyi              |  67 +++++
 features/stubs/behave/reporter/__init__.pyi   |   0
 features/stubs/behave/reporter/base.pyi       |   8 +
 features/stubs/behave/reporter/junit.pyi      |  55 ++++
 features/stubs/behave/reporter/summary.pyi    |  25 ++
 features/stubs/behave/runner.pyi              |  88 ++++++
 features/stubs/behave/runner_util.pyi         |  62 ++++
 features/stubs/behave/step_registry.pyi       |  34 +++
 features/stubs/behave/tag_expression.pyi      |  15 +
 features/stubs/behave/tag_matcher.pyi         |  92 ++++++
 features/stubs/behave/textutil.pyi            |  16 ++
 features/stubs/behave/userdata.pyi            |  48 ++++
 poetry.lock                                   |  64 ++++-
 pyproject.toml                                |   2 +
 62 files changed, 2817 insertions(+), 7 deletions(-)
 create mode 100644 features/account_address.feature
 create mode 100644 features/bcs_deserialization.feature
 create mode 100644 features/bcs_serialization.feature
 create mode 100644 features/steps/account_address.py
 create mode 100644 features/steps/bcs.py
 create mode 100644 features/steps/common.py
 create mode 100644 features/stubs/behave/__init__.pyi
 create mode 100644 features/stubs/behave/_stepimport.pyi
 create mode 100644 features/stubs/behave/_types.pyi
 create mode 100644 features/stubs/behave/api/__init__.pyi
 create mode 100644 features/stubs/behave/api/async_step.pyi
 create mode 100644 features/stubs/behave/capture.pyi
 create mode 100644 features/stubs/behave/compat/__init__.pyi
 create mode 100644 features/stubs/behave/compat/collections.pyi
 create mode 100644 features/stubs/behave/configuration.pyi
 create mode 100644 features/stubs/behave/contrib/__init__.pyi
 create mode 100644 features/stubs/behave/contrib/formatter_missing_steps.pyi
 create mode 100644 features/stubs/behave/contrib/scenario_autoretry.pyi
 create mode 100644 features/stubs/behave/contrib/steps/__init__.pyi
 create mode 100644 features/stubs/behave/contrib/substep_dirs.pyi
 create mode 100644 features/stubs/behave/fixture.pyi
 create mode 100644 features/stubs/behave/formatter/__init__.pyi
 create mode 100644 features/stubs/behave/formatter/_builtins.pyi
 create mode 100644 features/stubs/behave/formatter/_registry.pyi
 create mode 100644 features/stubs/behave/formatter/ansi_escapes.pyi
 create mode 100644 features/stubs/behave/formatter/base.pyi
 create mode 100644 features/stubs/behave/formatter/formatters.pyi
 create mode 100644 features/stubs/behave/formatter/json.pyi
 create mode 100644 features/stubs/behave/formatter/null.pyi
 create mode 100644 features/stubs/behave/formatter/plain.pyi
 create mode 100644 features/stubs/behave/formatter/pretty.pyi
 create mode 100644 features/stubs/behave/formatter/progress.pyi
 create mode 100644 features/stubs/behave/formatter/rerun.pyi
 create mode 100644 features/stubs/behave/formatter/sphinx_steps.pyi
 create mode 100644 features/stubs/behave/formatter/sphinx_util.pyi
 create mode 100644 features/stubs/behave/formatter/steps.pyi
 create mode 100644 features/stubs/behave/formatter/tags.pyi
 create mode 100644 features/stubs/behave/i18n.pyi
 create mode 100644 features/stubs/behave/importer.pyi
 create mode 100644 features/stubs/behave/json_parser.pyi
 create mode 100644 features/stubs/behave/log_capture.pyi
 create mode 100644 features/stubs/behave/matchers.pyi
 create mode 100644 features/stubs/behave/model.pyi
 create mode 100644 features/stubs/behave/model_core.pyi
 create mode 100644 features/stubs/behave/model_describe.pyi
 create mode 100644 features/stubs/behave/parser.pyi
 create mode 100644 features/stubs/behave/reporter/__init__.pyi
 create mode 100644 features/stubs/behave/reporter/base.pyi
 create mode 100644 features/stubs/behave/reporter/junit.pyi
 create mode 100644 features/stubs/behave/reporter/summary.pyi
 create mode 100644 features/stubs/behave/runner.pyi
 create mode 100644 features/stubs/behave/runner_util.pyi
 create mode 100644 features/stubs/behave/step_registry.pyi
 create mode 100644 features/stubs/behave/tag_expression.pyi
 create mode 100644 features/stubs/behave/tag_matcher.pyi
 create mode 100644 features/stubs/behave/textutil.pyi
 create mode 100644 features/stubs/behave/userdata.pyi

diff --git a/CHANGELOG.md b/CHANGELOG.md
index da4df3c..4eeacae 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,8 @@ All notable changes to the Aptos Python SDK will be captured in this file. This
 ## 0.9.0
 - Add Multikey support for Python, with an example
 - Deprecate and remove non-BCS transaction submission
+- Set max Uleb128 to MAX_U32
+- Add Behave behavioral specifications for BCS and AccountAddress
 
 ## 0.8.6
 - add client for graphql indexer service with light demo in coin transfer
diff --git a/Makefile b/Makefile
index 494851a..de57e49 100644
--- a/Makefile
+++ b/Makefile
@@ -3,19 +3,23 @@
 
 test:
 	poetry run python -m unittest discover -s aptos_sdk/ -p '*.py' -t ..
+	poetry run behave
 
 test-coverage:
 	poetry run python -m coverage run -m unittest discover -s aptos_sdk/ -p '*.py' -t ..
 	poetry run python -m coverage report
 
+test-spec:
+	poetry run behave
+
 fmt:
-	find ./examples ./aptos_sdk . -type f -name "*.py" | xargs poetry run autoflake -i -r --remove-all-unused-imports --remove-unused-variables --ignore-init-module-imports
-	poetry run isort aptos_sdk examples
-	poetry run black aptos_sdk examples
+	find ./examples ./aptos_sdk ./features . -type f -name "*.py" | xargs poetry run autoflake -i -r --remove-all-unused-imports --remove-unused-variables --ignore-init-module-imports
+	poetry run isort aptos_sdk examples features
+	poetry run black aptos_sdk examples features
 
 lint:
-	poetry run mypy aptos_sdk examples
-	poetry run flake8 aptos_sdk examples
+	poetry run mypy aptos_sdk examples features
+	poetry run flake8 aptos_sdk examples features
 
 examples:
 	poetry run python -m examples.aptos_token
diff --git a/aptos_sdk/bcs.py b/aptos_sdk/bcs.py
index ba50e40..b626c61 100644
--- a/aptos_sdk/bcs.py
+++ b/aptos_sdk/bcs.py
@@ -129,7 +129,7 @@ def uleb128(self) -> int:
                 break
             shift += 7
 
-        if value > MAX_U128:
+        if value > MAX_U32:
             raise Exception("Unexpectedly large uleb128 value")
 
         return value
diff --git a/features/account_address.feature b/features/account_address.feature
new file mode 100644
index 0000000..fcd5bbd
--- /dev/null
+++ b/features/account_address.feature
@@ -0,0 +1,68 @@
+Feature: Account Address
+"""
+AccountAddress is a 32-byte value that represents an address on chain.
+"""
+
+  Scenario Outline: Parse account address <label>
+    Given string <str>
+    When I parse the account address
+    Then the result should be address <address>
+    Examples:
+      | label                     | str                                          | address                                    |
+      | address one short         | "0x1"                                        | 0x1                                        |
+      | address one long          | "0x0000000000000000000000000000000000000001" | 0x1                                        |
+      | address two short         | "0x2"                                        | 0x2                                        |
+      | address two long          | "0x0000000000000000000000000000000000000002" | 0x2                                        |
+      | full address              | "0x1111111111111111111111111111111111111112" | 0x1111111111111111111111111111111111111112 |
+      | address with leading 0    | "0x0111111111111111111111111111111111111112" | 0x0111111111111111111111111111111111111112 |
+      | address missing leading 0 | "0x111111111111111111111111111111111111112"  | 0x111111111111111111111111111111111111112  |
+
+  Scenario Outline: Address <label> to string
+  """
+  TODO: AIP-40 doesn't shorten 0xB
+  TODO: Uppercase or lowercase?
+  """
+    Given address <address>
+    When I convert the address to a string
+    Then the result should be string <str>
+
+    Examples:
+      | label                  | str                                                                  | address                                                            |
+      | address one            | "0x1"                                                                | 0x1                                                                |
+      | address two            | "0x2"                                                                | 0x2                                                                |
+      | address two long       | "0x2"                                                                | 0x0000000000000000000000000000000000000002                         |
+      | address A              | "0xa"                                                                | 0xA                                                                |
+      | address B              | "0xb"                                                                | 0xB                                                                |
+      | full address           | "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" | 0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef |
+      | address with leading 0 | "0x0000000000000000000000000111111111111111111111111111111111111112" | 0x0111111111111111111111111111111111111112                         |
+
+  Scenario Outline: Address <label> to string long
+  """
+  This is required for indexer support
+  """
+    Given address <address>
+    When I convert the address to a string long
+    Then the result should be string <str>
+
+    Examples:
+      | label                     | str                                                                  | address                                                            |
+      | address one               | "0x0000000000000000000000000000000000000000000000000000000000000001" | 0x1                                                                |
+      | address two               | "0x0000000000000000000000000000000000000000000000000000000000000002" | 0x2                                                                |
+      | address A                 | "0x000000000000000000000000000000000000000000000000000000000000000a" | 0xA                                                                |
+      | address B                 | "0x000000000000000000000000000000000000000000000000000000000000000b" | 0xB                                                                |
+      | full address              | "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" | 0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef |
+      | address with leading 0    | "0x0000000000000000000000000111111111111111111111111111111111111112" | 0x0111111111111111111111111111111111111112                         |
+      | address missing leading 0 | "0x0000000000000000000000000111111111111111111111111111111111111112" | 0x111111111111111111111111111111111111112                          |
+
+
+  Scenario Outline: Parse account address with invalid address <label>
+    Given string "<address>"
+    When I parse the account address
+    Then I should fail to parse the account address
+    Examples:
+      | label                       | address                                                             |
+      | address no digits           | 0x                                                                  |
+      | address too long            | 0xA0000000000000000000000000000000000000000000000000000000000000001 |
+      | address too long with zeros | 0x00000000000000000000000000000000000000000000000000000000000000001 |
+      | address invalid character   | 0xG                                                                 |
+
diff --git a/features/bcs_deserialization.feature b/features/bcs_deserialization.feature
new file mode 100644
index 0000000..e734b21
--- /dev/null
+++ b/features/bcs_deserialization.feature
@@ -0,0 +1,268 @@
+Feature: Binary Canonical Serialization(BCS) Deserialization
+"""
+  https://github.com/diem/bcs
+
+  TODO List:
+    * Add a struct for testing
+    * Add possible invalid input number scenarios?  It's really language specific though
+    * Add invalid UTF-8 string deserialization
+    * Add invalid sequence item deserialization
+    * Add invalid struct deserialization
+    * Add invalid custom error struct deserialization
+"""
+
+  Scenario Outline: It must be able to deserialize <label> as an address
+    Given bytes <bytes>
+    When I deserialize as address
+    Then the result should be address <value>
+
+    Examples:
+      | label                         | value                                                              | bytes                                                              |
+      | address zero                  | 0x0                                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 |
+      | address one                   | 0x1                                                                | 0x0000000000000000000000000000000000000000000000000000000000000001 |
+      | an address with leading zeros | 0x123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF  | 0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF |
+      | a full address                | 0xA123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF | 0xA123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF |
+
+  Scenario Outline: It must be able to deserialize <value> as a bool
+    Given bytes <bytes>
+    When I deserialize as bool
+    Then the result should be bool <value>
+
+    Examples:
+      | value | bytes |
+      | false | 0x00  |
+      | true  | 0x01  |
+
+  Scenario Outline: It must not succeed if the bool type is not 0x00 or 0x01
+    Given bytes <bytes>
+    When I deserialize as bool
+    Then the deserialization should fail
+
+    Examples:
+      | bytes |
+      | 0x02  |
+      | 0xFF  |
+
+  Scenario Outline: It must be able to deserialize <label> as an u8
+    Given bytes <bytes>
+    When I deserialize as u8
+    Then the result should be u8 <value>
+
+    Examples:
+      | label                    | value | bytes |
+      | zero                     | 0     | 0x00  |
+      | one                      | 1     | 0x01  |
+      | the highest value (0xFF) | 255   | 0xFF  |
+
+  Scenario Outline: It must be able to deserialize <label> as an u16
+    Given bytes <bytes>
+    When I deserialize as u16
+    Then the result should be u16 <value>
+
+    Examples:
+      | label                      | value | bytes  |
+      | zero                       | 0     | 0x0000 |
+      | one                        | 1     | 0x0100 |
+      | 0xFF                       | 255   | 0xFF00 |
+      | 0x100                      | 256   | 0x0001 |
+      | the highest value (0xFFFF) | 65535 | 0xFFFF |
+
+  Scenario Outline: It must be able to deserialize <label> as an u32
+    Given bytes <bytes>
+    When I deserialize as u32
+    Then the result should be u32 <value>
+
+    Examples:
+      | label                          | value      | bytes      |
+      | zero                           | 0          | 0x00000000 |
+      | one                            | 1          | 0x01000000 |
+      | 0xFF                           | 255        | 0xFF000000 |
+      | 0x100                          | 256        | 0x00010000 |
+      | 0xFFFF                         | 65535      | 0xFFFF0000 |
+      | 0x100000                       | 65536      | 0x00000100 |
+      | 0xFFFFFF                       | 16777215   | 0xFFFFFF00 |
+      | 0x1000000                      | 16777216   | 0x00000001 |
+      | the highest value (0xFFFFFFFF) | 4294967295 | 0xFFFFFFFF |
+
+  Scenario Outline: It must be able to deserialize <label> as an u64
+    Given bytes <bytes>
+    When I deserialize as u64
+    Then the result should be u64 <value>
+
+    Examples:
+      | label                                 | value                | bytes              |
+      | zero                                  | 0                    | 0x0000000000000000 |
+      | one                                   | 1                    | 0x0100000000000000 |
+      | 0xFF                                  | 255                  | 0xFF00000000000000 |
+      | 0x100                                 | 256                  | 0x0001000000000000 |
+      | 0xFFFF                                | 65535                | 0xFFFF000000000000 |
+      | 0x10000                               | 65536                | 0x0000010000000000 |
+      | 0xFFFFFF                              | 16777215             | 0xFFFFFF0000000000 |
+      | 0x1000000                             | 16777216             | 0x0000000100000000 |
+      | 0xFFFFFFFF                            | 4294967295           | 0xFFFFFFFF00000000 |
+      | 0x100000000                           | 4294967296           | 0x0000000001000000 |
+      | the highest value(0xFFFFFFFFFFFFFFFF) | 18446744073709551615 | 0xFFFFFFFFFFFFFFFF |
+
+  Scenario Outline: It must be able to deserialize <label> as an u128
+    Given bytes <bytes>
+    When I deserialize as u128
+    Then the result should be u128 <value>
+
+    Examples:
+      | label                                                  | value                                   | bytes                              |
+      | zero                                                   | 0                                       | 0x00000000000000000000000000000000 |
+      | one                                                    | 1                                       | 0x01000000000000000000000000000000 |
+      | 0xFF                                                   | 255                                     | 0xFF000000000000000000000000000000 |
+      | 0x100                                                  | 256                                     | 0x00010000000000000000000000000000 |
+      | 0xFFFF                                                 | 65535                                   | 0xFFFF0000000000000000000000000000 |
+      | 0x10000                                                | 65536                                   | 0x00000100000000000000000000000000 |
+      | 0xFFFFFFFF                                             | 4294967295                              | 0xFFFFFFFF000000000000000000000000 |
+      | 0x100000000                                            | 4294967296                              | 0x00000000010000000000000000000000 |
+      | the highest value (0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) | 340282366920938463463374607431768211455 | 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF |
+
+  Scenario Outline: It must be able to deserialize <label> as an u256
+    Given bytes <bytes>
+    When I deserialize as u256
+    Then the result should be u256 <value>
+
+    Examples:
+      | label                                                                                  | value                                                                          | bytes                                                              |
+      | zero                                                                                   | 0                                                                              | 0x0000000000000000000000000000000000000000000000000000000000000000 |
+      | one                                                                                    | 1                                                                              | 0x0100000000000000000000000000000000000000000000000000000000000000 |
+      | 0xFF                                                                                   | 255                                                                            | 0xFF00000000000000000000000000000000000000000000000000000000000000 |
+      | 0x1000                                                                                 | 256                                                                            | 0x0001000000000000000000000000000000000000000000000000000000000000 |
+      | the highest value (0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) | 115792089237316195423570985008687907853269984665640564039457584007913129639935 | 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF |
+
+
+  Scenario Outline: It must be able to deserialize <label> as an uleb128
+    Given bytes <bytes>
+    When I deserialize as uleb128
+    Then the result should be u32 <value>
+
+    Examples:
+      | label                      | value      | bytes        |
+      | zero                       | 0          | 0x00         |
+      | one                        | 1          | 0x01         |
+      | largest single byte (127)  | 127        | 0x7F         |
+      | smallest double byte (128) | 128        | 0x8001       |
+      | other double byte (240)    | 240        | 0xF001       |
+      | 255                        | 255        | 0xFF01       |
+      | three bytes (65535)        | 65535      | 0xFFFF03     |
+      | four bytes (16777215)      | 16777215   | 0xFFFFFF07   |
+      | max u32 (4294966295)       | 4294967295 | 0xFFFFFFFF0F |
+
+  Scenario Outline: It must not succeed if the uleb128 type is not a valid uleb128 <label>
+    Given bytes <bytes>
+    When I deserialize as uleb128
+    Then the deserialization should fail
+
+    Examples:
+      | label             | bytes        |
+      | Missing next byte | 0x80         |
+      | Too large         | 0xFFFFFFFF10 |
+
+  Scenario Outline: It must be able to deserialize <label> as fixed bytes with length <length>
+    Given bytes <bytes>
+    When I deserialize as fixed bytes with length <length>
+    Then the result should be bytes <value>
+
+    Examples:
+      | label             | value  | bytes  | length |
+      | zero length fixed | 0x     | 0x     | 0      |
+      | zero single byte  | 0x00   | 0x00   | 1      |
+      | single byte       | 0x7F   | 0x7F   | 1      |
+      | two bytes         | 0x0102 | 0x0102 | 2      |
+
+  Scenario: It must not succeed deserializing fixed bytes, if the input is too short
+    Given bytes 0x00
+    When I deserialize as fixed bytes with length 2
+    Then the deserialization should fail
+
+  Scenario Outline: It must be able to deserialize <label> as bytes
+    Given bytes <bytes>
+    When I deserialize as bytes
+    Then the result should be bytes <value>
+
+    Examples:
+      | label                                             | value                                                                                                                                                                                                                                                              | bytes                                                                                                                                                                                                                                                                  |
+      | zero byte                                         | 0x00                                                                                                                                                                                                                                                               | 0x0100                                                                                                                                                                                                                                                                 |
+      | single byte                                       | 0x7F                                                                                                                                                                                                                                                               | 0x017F                                                                                                                                                                                                                                                                 |
+      | two bytes                                         | 0x0102                                                                                                                                                                                                                                                             | 0x020102                                                                                                                                                                                                                                                               |
+      | long bytes with one length byte (127 characters)  | 0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCD   | 0x7F0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCD     |
+      | long bytes with two length bytes (128 characters) | 0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF | 0x80010123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF |
+
+
+  Scenario Outline: It must be able to deserialize <label> as a string <value> from <bytes>
+    Given bytes <bytes>
+    When I deserialize as string
+    Then the result should be string <value>
+
+    Examples:
+      | label                  | value      | bytes                |
+      | empty string           | ""         | 0x00                 |
+      | uppercase A            | "A"        | 0x0141               |
+      | lowercase a            | "a"        | 0x0161               |
+      | three character string | "abc"      | 0x03616263           |
+      | four character string  | "abcd"     | 0x0461626364         |
+      | numbers and letters    | "1234abcd" | 0x083132333461626364 |
+      | emojis                 | "😀🚀"     | 0x08F09F9880F09F9A80 |
+
+  Scenario Outline: It must be able to deserialize <label> as a sequence of <type>
+    Given bytes <bytes>
+    When I deserialize as sequence of <type>
+    Then the result should be sequence of <type> <value>
+
+    Examples:
+      | label          | type    | value        | bytes                                                                                                                                |
+      | no bool        | bool    | []           | 0x00                                                                                                                                 |
+      | single bool    | bool    | [true]       | 0x0101                                                                                                                               |
+      | double bool    | bool    | [false,true] | 0x020001                                                                                                                             |
+      | no u8          | u8      | []           | 0x00                                                                                                                                 |
+      | single u8      | u8      | [0]          | 0x0100                                                                                                                               |
+      | double u8      | u8      | [1,3]        | 0x020103                                                                                                                             |
+      | no u16         | u16     | []           | 0x00                                                                                                                                 |
+      | single u16     | u16     | [0]          | 0x010000                                                                                                                             |
+      | double u16     | u16     | [1,3]        | 0x0201000300                                                                                                                         |
+      | no u32         | u32     | []           | 0x00                                                                                                                                 |
+      | single u32     | u32     | [0]          | 0x0100000000                                                                                                                         |
+      | double u32     | u32     | [1,3]        | 0x020100000003000000                                                                                                                 |
+      | no u64         | u64     | []           | 0x00                                                                                                                                 |
+      | single u64     | u64     | [0]          | 0x010000000000000000                                                                                                                 |
+      | double u64     | u64     | [1,3]        | 0x0201000000000000000300000000000000                                                                                                 |
+      | no u128        | u128    | []           | 0x00                                                                                                                                 |
+      | single u128    | u128    | [0]          | 0x0100000000000000000000000000000000                                                                                                 |
+      | double u128    | u128    | [1,3]        | 0x020100000000000000000000000000000003000000000000000000000000000000                                                                 |
+      | no u256        | u256    | []           | 0x00                                                                                                                                 |
+      | single u256    | u256    | [0]          | 0x010000000000000000000000000000000000000000000000000000000000000000                                                                 |
+      | double u256    | u256    | [1,3]        | 0x0201000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000 |
+      | no uleb128     | uleb128 | []           | 0x00                                                                                                                                 |
+      | single uleb128 | uleb128 | [0]          | 0x0100                                                                                                                               |
+      | double uleb128 | uleb128 | [128,127]    | 0x0280017F                                                                                                                           |
+      | no address     | address | []           | 0x00                                                                                                                                 |
+      | single address | address | [0x1]        | 0x010000000000000000000000000000000000000000000000000000000000000001                                                                 |
+      | double address | address | [0x2,0x0]    | 0x0200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000 |
+      | no string      | string  | []           | 0x00                                                                                                                                 |
+      | single string  | string  | ["😀🚀"]     | 0x0108F09F9880F09F9A80                                                                                                               |
+      | double string  | string  | ["a","b"]    | 0x0201610162                                                                                                                         |
+
+  Scenario Outline: It must not succeed if there are not enough bytes to deserialize <label>
+    Given bytes <bytes>
+    When I deserialize as <type>
+    Then the deserialization should fail
+
+    Examples:
+      | label                            | type    | bytes                                                            |
+      | bool                             | bool    | 0x                                                               |
+      | u8                               | u8      | 0x                                                               |
+      | u16                              | u16     | 0x00                                                             |
+      | u32                              | u32     | 0x000000                                                         |
+      | u64                              | u64     | 0x00000000000000                                                 |
+      | u128                             | u128    | 0x000000000000000000000000000000                                 |
+      | u256                             | u256    | 0x00000000000000000000000000000000000000000000000000000000000000 |
+      | address                          | address | 0x00000000000000000000000000000000000000000000000000000000000000 |
+      | short address                    | address | 0x01                                                             |
+      | bytes without length             | bytes   | 0x                                                               |
+      | bytes with length and no values  | bytes   | 0x01                                                             |
+      | string without length            | string  | 0x                                                               |
+      | string with length and no values | string  | 0x01                                                             |
+    # TODO check similar for sequences
diff --git a/features/bcs_serialization.feature b/features/bcs_serialization.feature
new file mode 100644
index 0000000..3018500
--- /dev/null
+++ b/features/bcs_serialization.feature
@@ -0,0 +1,224 @@
+Feature: Binary Canonical Serialization(BCS) Serialization
+"""
+  https://github.com/diem/bcs
+
+  TODO List:
+  * Add a struct for testing
+  * Add some more test cases for each
+  * Add struct sequence tests
+  * Add for custom error handling on structs?
+  * Do we add a fixed length test that doesn't match length of input (disallowed in Go entirely)
+"""
+
+  # TODO Do we merge all of the primitives into one big scenario outline?
+
+  Scenario Outline: It must be able to serialize <label> as an address
+    Given address <value>
+    When I serialize as address
+    Then the result should be bytes <bytes>
+
+    Examples:
+      | label                         | value                                                              | bytes                                                              |
+      | address zero                  | 0x0                                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 |
+      | address one                   | 0x1                                                                | 0x0000000000000000000000000000000000000000000000000000000000000001 |
+      | an address with leading zeros | 0x123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF  | 0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF |
+      | a full address                | 0xA123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF | 0xA123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF |
+
+  Scenario Outline: It must be able to serialize <value> as a bool
+    Given bool <value>
+    When I serialize as bool
+    Then the result should be bytes <bytes>
+
+    Examples:
+      | value | bytes |
+      | false | 0x00  |
+      | true  | 0x01  |
+
+  Scenario Outline: It must be able to serialize <label> as an u8
+    Given u8 <value>
+    When I serialize as u8
+    Then the result should be bytes <bytes>
+
+    Examples:
+      | label                    | value | bytes |
+      | zero                     | 0     | 0x00  |
+      | one                      | 1     | 0x01  |
+      | the highest value (0xFF) | 255   | 0xFF  |
+
+  Scenario Outline: It must be able to serialize <label> as an u16
+    Given u16 <value>
+    When I serialize as u16
+    Then the result should be bytes <bytes>
+
+    Examples:
+      | label                      | value | bytes  |
+      | zero                       | 0     | 0x0000 |
+      | one                        | 1     | 0x0100 |
+      | 0xFF                       | 255   | 0xFF00 |
+      | 0x100                      | 256   | 0x0001 |
+      | the highest value (0xFFFF) | 65535 | 0xFFFF |
+
+  Scenario Outline: It must be able to serialize <label> as an u32
+    Given u32 <value>
+    When I serialize as u32
+    Then the result should be bytes <bytes>
+
+    Examples:
+      | label                          | value      | bytes      |
+      | zero                           | 0          | 0x00000000 |
+      | one                            | 1          | 0x01000000 |
+      | 0xFF                           | 255        | 0xFF000000 |
+      | 0x100                          | 256        | 0x00010000 |
+      | 0xFFFF                         | 65535      | 0xFFFF0000 |
+      | 0x100000                       | 65536      | 0x00000100 |
+      | 0xFFFFFF                       | 16777215   | 0xFFFFFF00 |
+      | 0x1000000                      | 16777216   | 0x00000001 |
+      | the highest value (0xFFFFFFFF) | 4294967295 | 0xFFFFFFFF |
+
+  Scenario Outline: It must be able to serialize <label> as an u64
+    Given u64 <value>
+    When I serialize as u64
+    Then the result should be bytes <bytes>
+
+    Examples:
+      | label                                 | value                | bytes              |
+      | zero                                  | 0                    | 0x0000000000000000 |
+      | one                                   | 1                    | 0x0100000000000000 |
+      | 0xFF                                  | 255                  | 0xFF00000000000000 |
+      | 0x100                                 | 256                  | 0x0001000000000000 |
+      | 0xFFFF                                | 65535                | 0xFFFF000000000000 |
+      | 0x10000                               | 65536                | 0x0000010000000000 |
+      | 0xFFFFFF                              | 16777215             | 0xFFFFFF0000000000 |
+      | 0x1000000                             | 16777216             | 0x0000000100000000 |
+      | 0xFFFFFFFF                            | 4294967295           | 0xFFFFFFFF00000000 |
+      | 0x100000000                           | 4294967296           | 0x0000000001000000 |
+      | the highest value(0xFFFFFFFFFFFFFFFF) | 18446744073709551615 | 0xFFFFFFFFFFFFFFFF |
+
+  Scenario Outline: It must be able to serialize <label> as an u128
+    Given u128 <value>
+    When I serialize as u128
+    Then the result should be bytes <bytes>
+
+    # TODO Fill in more examples
+    Examples:
+      | label                                                  | value                                   | bytes                              |
+      | zero                                                   | 0                                       | 0x00000000000000000000000000000000 |
+      | one                                                    | 1                                       | 0x01000000000000000000000000000000 |
+      | 0xFF                                                   | 255                                     | 0xFF000000000000000000000000000000 |
+      | 0x100                                                  | 256                                     | 0x00010000000000000000000000000000 |
+      | 0xFFFF                                                 | 65535                                   | 0xFFFF0000000000000000000000000000 |
+      | 0x10000                                                | 65536                                   | 0x00000100000000000000000000000000 |
+      | 0xFFFFFFFF                                             | 4294967295                              | 0xFFFFFFFF000000000000000000000000 |
+      | 0x100000000                                            | 4294967296                              | 0x00000000010000000000000000000000 |
+      | the highest value (0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) | 340282366920938463463374607431768211455 | 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF |
+
+  Scenario Outline: It must be able to serialize <label> as an u256
+    Given u256 <value>
+    When I serialize as u256
+    Then the result should be bytes <bytes>
+
+    # TODO Fill in more examples
+    Examples:
+      | label                                                                                  | value                                                                          | bytes                                                              |
+      | zero                                                                                   | 0                                                                              | 0x0000000000000000000000000000000000000000000000000000000000000000 |
+      | one                                                                                    | 1                                                                              | 0x0100000000000000000000000000000000000000000000000000000000000000 |
+      | 0xFF                                                                                   | 255                                                                            | 0xFF00000000000000000000000000000000000000000000000000000000000000 |
+      | 0x1000                                                                                 | 256                                                                            | 0x0001000000000000000000000000000000000000000000000000000000000000 |
+      | the highest value (0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) | 115792089237316195423570985008687907853269984665640564039457584007913129639935 | 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF |
+
+  Scenario Outline: It must be able to serialize <label> as an uleb128
+    Given u32 <value>
+    When I serialize as uleb128
+    Then the result should be bytes <bytes>
+
+    # TODO Fill in more examples
+    Examples:
+      | label                      | value      | bytes        |
+      | zero                       | 0          | 0x00         |
+      | one                        | 1          | 0x01         |
+      | largest single byte (127)  | 127        | 0x7F         |
+      | smallest double byte (128) | 128        | 0x8001       |
+      | other double byte (240)    | 240        | 0xF001       |
+      | 255                        | 255        | 0xFF01       |
+      | three bytes (65535)        | 65535      | 0xFFFF03     |
+      | four bytes (16777215)      | 16777215   | 0xFFFFFF07   |
+      | max u32 (4294966295)       | 4294967295 | 0xFFFFFFFF0F |
+
+
+  Scenario Outline: It must be able to serialize <label> as fixed bytes
+    Given bytes <value>
+    When I serialize as fixed bytes with length <length>
+    Then the result should be bytes <bytes>
+
+    Examples:
+      | label            | value  | bytes  | length |
+      | zero single byte | 0x00   | 0x00   | 1      |
+      | single byte      | 0x7F   | 0x7F   | 1      |
+      | two bytes        | 0x0102 | 0x0102 | 2      |
+
+  Scenario Outline: It must be able to serialize <label> as bytes
+    Given bytes <value>
+    When I serialize as bytes
+    Then the result should be bytes <bytes>
+
+    Examples:
+      | label                                             | value                                                                                                                                                                                                                                                              | bytes                                                                                                                                                                                                                                                                  |
+      | zero byte                                         | 0x00                                                                                                                                                                                                                                                               | 0x0100                                                                                                                                                                                                                                                                 |
+      | single byte                                       | 0x7F                                                                                                                                                                                                                                                               | 0x017F                                                                                                                                                                                                                                                                 |
+      | two bytes                                         | 0x0102                                                                                                                                                                                                                                                             | 0x020102                                                                                                                                                                                                                                                               |
+      | long bytes with one length byte (127 characters)  | 0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCD   | 0x7F0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCD     |
+      | long bytes with two length bytes (128 characters) | 0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF | 0x80010123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF |
+
+  Scenario Outline: It must be able to serialize <label> as a string
+    Given string <value>
+    When I serialize as string
+    Then the result should be bytes <bytes>
+
+    Examples:
+      | label                  | value      | bytes                |
+      | empty string           | ""         | 0x00                 |
+      | uppercase A            | "A"        | 0x0141               |
+      | lowercase a            | "a"        | 0x0161               |
+      | three character string | "abc"      | 0x03616263           |
+      | four character string  | "abcd"     | 0x0461626364         |
+      | numbers and letters    | "1234abcd" | 0x083132333461626364 |
+      | emojis                 | "😀🚀"     | 0x08F09F9880F09F9A80 |
+
+
+  Scenario Outline: It must be able to serialize <label> as a sequence of <type>
+    Given sequence of <type> <value>
+    When I serialize as sequence of <type>
+    Then the result should be bytes <bytes>
+
+    Examples:
+      | label          | type    | value        | bytes                                                                                                                                |
+      | no bool        | bool    | []           | 0x00                                                                                                                                 |
+      | single bool    | bool    | [true]       | 0x0101                                                                                                                               |
+      | double bool    | bool    | [false,true] | 0x020001                                                                                                                             |
+      | no u8          | u8      | []           | 0x00                                                                                                                                 |
+      | single u8      | u8      | [0]          | 0x0100                                                                                                                               |
+      | double u8      | u8      | [1,3]        | 0x020103                                                                                                                             |
+      | no u16         | u16     | []           | 0x00                                                                                                                                 |
+      | single u16     | u16     | [0]          | 0x010000                                                                                                                             |
+      | double u16     | u16     | [1,3]        | 0x0201000300                                                                                                                         |
+      | no u32         | u32     | []           | 0x00                                                                                                                                 |
+      | single u32     | u32     | [0]          | 0x0100000000                                                                                                                         |
+      | double u32     | u32     | [1,3]        | 0x020100000003000000                                                                                                                 |
+      | no u64         | u64     | []           | 0x00                                                                                                                                 |
+      | single u64     | u64     | [0]          | 0x010000000000000000                                                                                                                 |
+      | double u64     | u64     | [1,3]        | 0x0201000000000000000300000000000000                                                                                                 |
+      | no u128        | u128    | []           | 0x00                                                                                                                                 |
+      | single u128    | u128    | [0]          | 0x0100000000000000000000000000000000                                                                                                 |
+      | double u128    | u128    | [1,3]        | 0x020100000000000000000000000000000003000000000000000000000000000000                                                                 |
+      | no u256        | u256    | []           | 0x00                                                                                                                                 |
+      | single u256    | u256    | [0]          | 0x010000000000000000000000000000000000000000000000000000000000000000                                                                 |
+      | double u256    | u256    | [1,3]        | 0x0201000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000 |
+      | no uleb128     | uleb128 | []           | 0x00                                                                                                                                 |
+      | single uleb128 | uleb128 | [0]          | 0x0100                                                                                                                               |
+      | double uleb128 | uleb128 | [128,127]    | 0x0280017F                                                                                                                           |
+      | no address     | address | []           | 0x00                                                                                                                                 |
+      | single address | address | [0x1]        | 0x010000000000000000000000000000000000000000000000000000000000000001                                                                 |
+      | double address | address | [0x2,0x0]    | 0x0200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000 |
+      | no string      | string  | []           | 0x00                                                                                                                                 |
+      | single string  | string  | ["😀🚀"]     | 0x0108F09F9880F09F9A80                                                                                                               |
+      | double string  | string  | ["a","b"]    | 0x0201610162                                                                                                                         |
diff --git a/features/steps/account_address.py b/features/steps/account_address.py
new file mode 100644
index 0000000..210ac6e
--- /dev/null
+++ b/features/steps/account_address.py
@@ -0,0 +1,34 @@
+from behave import then, use_step_matcher, when
+
+from aptos_sdk.account_address import AccountAddress
+from aptos_sdk.bcs import Serializer
+
+# Use regular expressions
+use_step_matcher("re")
+
+
+@when(r"I parse the account address")
+def when_parse_account_address(context):
+    try:
+        context.output = AccountAddress.from_str_relaxed(context.input)
+    except Exception as e:
+        context.output = e
+
+
+@when(r"I convert the address to a string")
+def when_account_address_to_string(context):
+    context.output = str(context.input)
+
+
+@when(r"I convert the address to a string long")
+def when_account_address_to_string_long(context):
+    # TODO make more straightforward, needed for indexer
+    ser = Serializer()
+    ser.struct(context.input)
+    bytes = ser.output()
+    context.output = "0x" + bytes.hex()
+
+
+@then(r"I should fail to parse the account address")
+def then_fail_account_address(context):
+    assert isinstance(context.output, Exception)
diff --git a/features/steps/bcs.py b/features/steps/bcs.py
new file mode 100644
index 0000000..79d4337
--- /dev/null
+++ b/features/steps/bcs.py
@@ -0,0 +1,172 @@
+import typing
+
+from behave import then, use_step_matcher, when
+
+from aptos_sdk.account_address import AccountAddress
+from aptos_sdk.bcs import Deserializer, Serializer
+
+# Use regular expressions
+use_step_matcher("re")
+
+
+@when(r"I serialize as (?P<input_type>[a-zA-Z0-9]+)")
+def when_serialize(context: typing.Any, input_type: str):
+    ser = Serializer()
+
+    if input_type == "bool":
+        ser.bool(context.input)
+    elif input_type == "u8":
+        ser.u8(context.input)
+    elif input_type == "u16":
+        ser.u16(context.input)
+    elif input_type == "u32":
+        ser.u32(context.input)
+    elif input_type == "u64":
+        ser.u64(context.input)
+    elif input_type == "u128":
+        ser.u128(context.input)
+    elif input_type == "u256":
+        ser.u256(context.input)
+    elif input_type == "uleb128":
+        ser.uleb128(context.input)
+    elif input_type == "address":
+        ser.struct(context.input)
+    elif input_type == "bytes":
+        # TODO: This should be more straightforward...
+        ser.uleb128(len(context.input))
+        ser.fixed_bytes(context.input)
+    elif input_type == "string":
+        ser.str(context.input)
+    else:
+        raise Exception("Unrecognized input type")
+
+    context.output = ser.output()
+
+
+@when(r"I deserialize as (?P<input_type>[a-zA-Z0-9]+)")
+def when_deserialize(context: typing.Any, input_type: str):
+    des = Deserializer(context.input)
+
+    try:
+        if input_type == "bool":
+            context.output = des.bool()
+        elif input_type == "u8":
+            context.output = des.u8()
+        elif input_type == "u16":
+            context.output = des.u16()
+        elif input_type == "u32":
+            context.output = des.u32()
+        elif input_type == "u64":
+            context.output = des.u64()
+        elif input_type == "u128":
+            context.output = des.u128()
+        elif input_type == "u256":
+            context.output = des.u256()
+        elif input_type == "uleb128":
+            context.output = des.uleb128()
+        elif input_type == "address":
+            context.output = des.struct(AccountAddress)
+        elif input_type == "bytes":
+            # TODO: This should be more straightforward...
+            length = des.uleb128()
+            context.output = des.fixed_bytes(length)
+        elif input_type == "string":
+            context.output = des.str()
+
+    except Exception as e:
+        context.output = e
+
+    # Catch all if it fails to be parsed
+    if context.output is None:
+        raise Exception("Unrecognized input type")
+
+
+@when(r"I serialize as sequence of (?P<input_type>[a-zA-Z0-9]+)")
+def when_serialize_sequence(context: typing.Any, input_type: str):
+    ser = Serializer()
+
+    if input_type == "bool":
+        seq_ser = Serializer.sequence_serializer(Serializer.bool)
+        seq_ser(ser, context.input)
+    elif input_type == "u8":
+        seq_ser = Serializer.sequence_serializer(Serializer.u8)
+        seq_ser(ser, context.input)
+    elif input_type == "u16":
+        seq_ser = Serializer.sequence_serializer(Serializer.u16)
+        seq_ser(ser, context.input)
+    elif input_type == "u32":
+        seq_ser = Serializer.sequence_serializer(Serializer.u32)
+        seq_ser(ser, context.input)
+    elif input_type == "u64":
+        seq_ser = Serializer.sequence_serializer(Serializer.u64)
+        seq_ser(ser, context.input)
+    elif input_type == "u128":
+        seq_ser = Serializer.sequence_serializer(Serializer.u128)
+        seq_ser(ser, context.input)
+    elif input_type == "u256":
+        seq_ser = Serializer.sequence_serializer(Serializer.u256)
+        seq_ser(ser, context.input)
+    elif input_type == "uleb128":
+        seq_ser = Serializer.sequence_serializer(Serializer.uleb128)
+        seq_ser(ser, context.input)
+    elif input_type == "address":
+        seq_ser = Serializer.sequence_serializer(Serializer.struct)
+        seq_ser(ser, context.input)
+    elif input_type == "string":
+        seq_ser = Serializer.sequence_serializer(Serializer.str)
+        seq_ser(ser, context.input)
+    else:
+        raise Exception("Unrecognized input type")
+
+    context.output = ser.output()
+
+
+@when(r"I deserialize as sequence of (?P<input_type>[a-zA-Z0-9]+)")
+def when_deserialize_sequence(context: typing.Any, input_type: str):
+    des = Deserializer(context.input)
+
+    if input_type == "bool":
+        context.output = des.sequence(Deserializer.bool)
+    elif input_type == "u8":
+        context.output = des.sequence(Deserializer.u8)
+    elif input_type == "u16":
+        context.output = des.sequence(Deserializer.u16)
+    elif input_type == "u32":
+        context.output = des.sequence(Deserializer.u32)
+    elif input_type == "u64":
+        context.output = des.sequence(Deserializer.u64)
+    elif input_type == "u128":
+        context.output = des.sequence(Deserializer.u128)
+    elif input_type == "u256":
+        context.output = des.sequence(Deserializer.u256)
+    elif input_type == "uleb128":
+        context.output = des.sequence(Deserializer.uleb128)
+    elif input_type == "address":
+        context.output = des.sequence(AccountAddress.deserialize)
+    elif input_type == "string":
+        context.output = des.sequence(Deserializer.str)
+    else:
+        raise Exception("Unrecognized input type")
+
+
+@when(r"I serialize as fixed bytes with length (?P<length>[0-9]+)")
+def when_serialize_fixed_bytes(context: typing.Any, length: str):
+    ser = Serializer()
+
+    # TODO: Do we check the length?
+    ser.fixed_bytes(context.input)
+    context.output = ser.output()
+
+
+@when(r"I deserialize as fixed bytes with length (?P<length>[0-9]+)")
+def when_deserialize_fixed_bytes(context: typing.Any, length: str):
+    try:
+        des = Deserializer(context.input)
+        context.output = des.fixed_bytes(int(length))
+    except Exception as e:
+        context.output = e
+
+
+@then(r"the deserialization should fail")
+def then_fail_deserialization(context: typing.Any):
+    assert isinstance(context.output, Exception)
diff --git a/features/steps/common.py b/features/steps/common.py
new file mode 100644
index 0000000..fb78011
--- /dev/null
+++ b/features/steps/common.py
@@ -0,0 +1,116 @@
+import typing
+
+from behave import given, then, use_step_matcher
+
+from aptos_sdk.account_address import AccountAddress
+
+# Use regular expressions
+use_step_matcher("re")
+
+
+@given(r"(?P<input_type>[a-zA-Z0-9]+) (?P<input_value>\S+)")
+def given_input(context: typing.Any, input_type: str, input_value: str):
+    if input_type == "bool":
+        context.input = parse_bool(input_value)
+    elif (
+        input_type == "u8"
+        or input_type == "u16"
+        or input_type == "u32"
+        or input_type == "u64"
+        or input_type == "u128"
+        or input_type == "u256"
+    ):
+        context.input = int(input_value)
+    elif input_type == "address":
+        context.input = AccountAddress.from_str_relaxed(input_value)
+    elif input_type == "bytes":
+        context.input = parse_hex(input_value)
+    elif input_type == "string":
+        context.input = parse_string(input_value)
+    else:
+        raise Exception("Unrecognized input type")
+
+
+@given(r"sequence of (?P<input_type>[a-zA-Z0-9]+) \[(?P<input_value>.*)]")
+def given_sequence_input(context: typing.Any, input_type: str, input_value: str):
+    context.input = parse_sequence(input_type, input_value)
+
+
+@then(r"the result should be (?P<expected_type>[a-zA-Z0-9]+) (?P<expected_value>\S+)")
+def then_result(context: typing.Any, expected_type: str, expected_value: str):
+    expected_val: bool | str | AccountAddress | bytes | int = expected_value
+    if expected_type == "bool":
+        expected_val = parse_bool(expected_value)
+    elif expected_type == "address":
+        expected_val = AccountAddress.from_str_relaxed(expected_value)
+    elif expected_type == "bytes":
+        expected_val = parse_hex(expected_value)
+    elif expected_type == "string":
+        expected_val = parse_string(expected_value)
+    elif (
+        expected_type == "u8"
+        or expected_type == "u16"
+        or expected_type == "u32"
+        or expected_type == "u64"
+        or expected_type == "u128"
+        or expected_type == "u256"
+        or expected_type == "uleb128"
+    ):
+        expected_val = int(expected_value)
+    assert context.output == expected_val, (
+        "Expected " + str(expected_value) + " but got " + str(context.output)
+    )
+
+
+@then(
+    r"the result should be sequence of (?P<expected_type>[a-zA-Z0-9]+) \[(?P<expected_value>\S*)]"
+)
+def then_result_sequence(context: typing.Any, expected_type: str, expected_value: str):
+    expected_val = parse_sequence(expected_type, expected_value)
+    assert context.output == expected_val, (
+        "Expected " + str(expected_val) + " but got " + str(context.output)
+    )
+
+
+def parse_sequence(input_type: str, input_value: str) -> typing.List[typing.Any]:
+    vals: typing.List[typing.Any] = []
+
+    # Skip early if there are no values
+    if len(input_value) == 0:
+        return vals
+
+    for val in input_value.split(","):
+        if input_type == "bool":
+            vals.append(parse_bool(val))
+        elif (
+            input_type == "u8"
+            or input_type == "u16"
+            or input_type == "u32"
+            or input_type == "u64"
+            or input_type == "u128"
+            or input_type == "u256"
+            or input_type == "uleb128"
+        ):
+            vals.append(int(val))
+        elif input_type == "address":
+            vals.append(AccountAddress.from_str_relaxed(val))
+        elif input_type == "bytes":
+            vals.append(parse_hex(val))
+        elif input_type == "string":
+            vals.append(parse_string(val))
+        else:
+            raise Exception("Unrecognized input type")
+
+    return vals
+
+
+def parse_hex(input_value: str):
+    return bytes.fromhex(input_value.removeprefix("0x"))
+
+
+def parse_bool(input_value: str):
+    return input_value == "true"
+
+
+def parse_string(input_value: str):
+    return input_value.removeprefix('"').removesuffix('"')
diff --git a/features/stubs/behave/__init__.pyi b/features/stubs/behave/__init__.pyi
new file mode 100644
index 0000000..e075842
--- /dev/null
+++ b/features/stubs/behave/__init__.pyi
@@ -0,0 +1,32 @@
+from behave.fixture import fixture as fixture
+from behave.fixture import use_fixture as use_fixture
+from behave.matchers import register_type as register_type
+from behave.matchers import step_matcher as step_matcher
+from behave.matchers import use_step_matcher as use_step_matcher
+from behave.step_registry import *
+
+__all__ = [
+    "given",
+    "when",
+    "then",
+    "step",
+    "use_step_matcher",
+    "register_type",
+    "Given",
+    "When",
+    "Then",
+    "Step",
+    "fixture",
+    "use_fixture",
+    "step_matcher",
+]
+
+# Names in __all__ with no definition:
+#   Given
+#   Step
+#   Then
+#   When
+#   given
+#   step
+#   then
+#   when
diff --git a/features/stubs/behave/_stepimport.pyi b/features/stubs/behave/_stepimport.pyi
new file mode 100644
index 0000000..5266d14
--- /dev/null
+++ b/features/stubs/behave/_stepimport.pyi
@@ -0,0 +1,38 @@
+from collections.abc import Generator
+from types import ModuleType
+
+from _typeshed import Incomplete
+
+def setup_api_with_step_decorators(module, step_registry) -> None: ...
+def setup_api_with_matcher_functions(module, matcher_factory) -> None: ...
+
+class FakeModule(ModuleType):
+    ensure_fake: bool
+    def __setitem__(self, name, value) -> None: ...
+
+class StepRegistryModule(FakeModule):
+    registry: Incomplete
+    def __init__(self, step_registry) -> None: ...
+
+class StepMatchersModule(FakeModule):
+    matcher_factory: Incomplete
+    use_default_step_matcher: Incomplete
+    get_matcher: Incomplete
+    def __init__(self, matcher_factory) -> None: ...
+
+class BehaveModule(FakeModule):
+    use_default_step_matcher: Incomplete
+    def __init__(
+        self, step_registry, matcher_factory: Incomplete | None = None
+    ) -> None: ...
+
+class StepImportModuleContext:
+    step_registry: Incomplete
+    matcher_factory: Incomplete
+    modules: Incomplete
+    def __init__(self, step_container) -> None: ...
+    def reset_current_matcher(self) -> None: ...
+
+unknown: Incomplete
+
+def use_step_import_modules(step_container) -> Generator[Incomplete, None, None]: ...
diff --git a/features/stubs/behave/_types.pyi b/features/stubs/behave/_types.pyi
new file mode 100644
index 0000000..32d2a5e
--- /dev/null
+++ b/features/stubs/behave/_types.pyi
@@ -0,0 +1,25 @@
+class Unknown: ...
+
+class ExceptionUtil:
+    @staticmethod
+    def get_traceback(exception): ...
+    @staticmethod
+    def set_traceback(exception, exc_traceback=...) -> None: ...
+    @classmethod
+    def has_traceback(cls, exception): ...
+    @classmethod
+    def describe(cls, exception, use_traceback: bool = False, prefix: str = ""): ...
+
+class ChainedExceptionUtil(ExceptionUtil):
+    @staticmethod
+    def get_cause(exception): ...
+    @staticmethod
+    def set_cause(exception, exc_cause) -> None: ...
+    @classmethod
+    def describe(
+        cls,
+        exception,
+        use_traceback: bool = False,
+        prefix: str = "",
+        style: str = "reversed",
+    ): ...
diff --git a/features/stubs/behave/api/__init__.pyi b/features/stubs/behave/api/__init__.pyi
new file mode 100644
index 0000000..e69de29
diff --git a/features/stubs/behave/api/async_step.pyi b/features/stubs/behave/api/async_step.pyi
new file mode 100644
index 0000000..cf0318f
--- /dev/null
+++ b/features/stubs/behave/api/async_step.pyi
@@ -0,0 +1,33 @@
+from _typeshed import Incomplete
+
+has_asyncio: bool
+
+def async_run_until_complete(
+    astep_func: Incomplete | None = None,
+    loop: Incomplete | None = None,
+    timeout: Incomplete | None = None,
+    async_context: Incomplete | None = None,
+    should_close: bool = False,
+): ...
+
+run_until_complete = async_run_until_complete
+
+class AsyncContext:
+    default_name: str
+    loop: Incomplete
+    tasks: Incomplete
+    name: Incomplete
+    should_close: Incomplete
+    def __init__(
+        self,
+        loop: Incomplete | None = None,
+        name: Incomplete | None = None,
+        should_close: bool = False,
+        tasks: Incomplete | None = None,
+    ) -> None: ...
+    def __del__(self) -> None: ...
+    def close(self) -> None: ...
+
+def use_or_create_async_context(
+    context, name: Incomplete | None = None, loop: Incomplete | None = None, **kwargs
+): ...
diff --git a/features/stubs/behave/capture.pyi b/features/stubs/behave/capture.pyi
new file mode 100644
index 0000000..45bc6a6
--- /dev/null
+++ b/features/stubs/behave/capture.pyi
@@ -0,0 +1,45 @@
+from collections.abc import Generator
+
+from _typeshed import Incomplete
+from behave.log_capture import LoggingCapture as LoggingCapture
+
+def add_text_to(value, more_text, separator: str = "\n"): ...
+
+class Captured:
+    empty: str
+    linesep: str
+    stdout: Incomplete
+    stderr: Incomplete
+    log_output: Incomplete
+    def __init__(
+        self,
+        stdout: Incomplete | None = None,
+        stderr: Incomplete | None = None,
+        log_output: Incomplete | None = None,
+    ) -> None: ...
+    def reset(self) -> None: ...
+    def __bool__(self) -> bool: ...
+    @property
+    def output(self): ...
+    def add(self, captured): ...
+    def make_report(self): ...
+    def __add__(self, other): ...
+    def __iadd__(self, other): ...
+
+class CaptureController:
+    config: Incomplete
+    stdout_capture: Incomplete
+    stderr_capture: Incomplete
+    log_capture: Incomplete
+    old_stdout: Incomplete
+    old_stderr: Incomplete
+    def __init__(self, config) -> None: ...
+    @property
+    def captured(self): ...
+    def setup_capture(self, context) -> None: ...
+    def start_capture(self) -> None: ...
+    def stop_capture(self) -> None: ...
+    def teardown_capture(self) -> None: ...
+    def make_capture_report(self): ...
+
+def capture_output(controller, enabled: bool = True) -> Generator[None, None, None]: ...
diff --git a/features/stubs/behave/compat/__init__.pyi b/features/stubs/behave/compat/__init__.pyi
new file mode 100644
index 0000000..e69de29
diff --git a/features/stubs/behave/compat/collections.pyi b/features/stubs/behave/compat/collections.pyi
new file mode 100644
index 0000000..123981e
--- /dev/null
+++ b/features/stubs/behave/compat/collections.pyi
@@ -0,0 +1,2 @@
+message: str
+OrderedDict = dict
diff --git a/features/stubs/behave/configuration.pyi b/features/stubs/behave/configuration.pyi
new file mode 100644
index 0000000..eea1e7a
--- /dev/null
+++ b/features/stubs/behave/configuration.pyi
@@ -0,0 +1,102 @@
+from collections.abc import Generator
+
+from _typeshed import Incomplete
+from behave._types import Unknown as Unknown
+from behave.formatter.base import StreamOpener as StreamOpener
+from behave.model import ScenarioOutline as ScenarioOutline
+from behave.model_core import FileLocation as FileLocation
+from behave.reporter.junit import JUnitReporter as JUnitReporter
+from behave.reporter.summary import SummaryReporter as SummaryReporter
+from behave.tag_expression import TagExpression as TagExpression
+from behave.textutil import select_best_encoding as select_best_encoding
+from behave.textutil import to_texts as to_texts
+from behave.userdata import UserData as UserData
+from behave.userdata import parse_user_define as parse_user_define
+
+ConfigParser: Incomplete
+
+class LogLevel:
+    names: Incomplete
+    @staticmethod
+    def parse(levelname, unknown_level: Incomplete | None = None): ...
+    @classmethod
+    def parse_type(cls, levelname): ...
+    @staticmethod
+    def to_string(level): ...
+
+class ConfigError(Exception): ...
+
+options: Incomplete
+raw_value_options: Incomplete
+
+def read_configuration(path): ...
+def config_filenames() -> Generator[Incomplete, None, None]: ...
+def load_configuration(defaults, verbose: bool = False) -> None: ...
+def setup_parser(): ...
+
+class Configuration:
+    defaults: Incomplete
+    cmdline_only_options: Incomplete
+    version: Incomplete
+    tags_help: Incomplete
+    lang_list: Incomplete
+    lang_help: Incomplete
+    default_tags: Incomplete
+    junit: Incomplete
+    logging_format: Incomplete
+    logging_datefmt: Incomplete
+    name: Incomplete
+    scope: Incomplete
+    steps_catalog: Incomplete
+    userdata: Incomplete
+    wip: Incomplete
+    formatters: Incomplete
+    reporters: Incomplete
+    name_re: Incomplete
+    outputs: Incomplete
+    include_re: Incomplete
+    exclude_re: Incomplete
+    scenario_outline_annotation_schema: Incomplete
+    steps_dir: str
+    environment_file: str
+    userdata_defines: Incomplete
+    more_formatters: Incomplete
+    paths: Incomplete
+    default_format: str
+    format: Incomplete
+    dry_run: bool
+    summary: bool
+    show_skipped: bool
+    quiet: bool
+    tags: Incomplete
+    color: bool
+    stop: bool
+    log_capture: bool
+    stdout_capture: bool
+    show_source: bool
+    show_snippets: bool
+    stage: Incomplete
+    stderr_capture: bool
+    def __init__(
+        self,
+        command_args: Incomplete | None = None,
+        load_config: bool = True,
+        verbose: Incomplete | None = None,
+        **kwargs
+    ) -> None: ...
+    def setup_outputs(self, args_outfiles: Incomplete | None = None) -> None: ...
+    def setup_formats(self) -> None: ...
+    def collect_unknown_formats(self): ...
+    @staticmethod
+    def build_name_re(names): ...
+    def exclude(self, filename): ...
+    def setup_logging(
+        self,
+        level: Incomplete | None = None,
+        configfile: Incomplete | None = None,
+        **kwargs
+    ) -> None: ...
+    def setup_model(self) -> None: ...
+    def setup_stage(self, stage: Incomplete | None = None) -> None: ...
+    def setup_userdata(self) -> None: ...
+    def update_userdata(self, data) -> None: ...
diff --git a/features/stubs/behave/contrib/__init__.pyi b/features/stubs/behave/contrib/__init__.pyi
new file mode 100644
index 0000000..e69de29
diff --git a/features/stubs/behave/contrib/formatter_missing_steps.pyi b/features/stubs/behave/contrib/formatter_missing_steps.pyi
new file mode 100644
index 0000000..e445b09
--- /dev/null
+++ b/features/stubs/behave/contrib/formatter_missing_steps.pyi
@@ -0,0 +1,19 @@
+from _typeshed import Incomplete
+from behave.runner_util import (
+    make_undefined_step_snippets as make_undefined_step_snippets,
+)
+
+from .steps import StepsUsageFormatter as StepsUsageFormatter
+
+STEP_MODULE_TEMPLATE: str
+
+class MissingStepsFormatter(StepsUsageFormatter):
+    name: str
+    description: str
+    template = STEP_MODULE_TEMPLATE
+    scope: str
+    def __init__(self, stream_opener, config) -> None: ...
+    def init_from_userdata(self, userdata) -> None: ...
+    stream: Incomplete
+    def close(self) -> None: ...
+    def report(self) -> None: ...
diff --git a/features/stubs/behave/contrib/scenario_autoretry.pyi b/features/stubs/behave/contrib/scenario_autoretry.pyi
new file mode 100644
index 0000000..3e67066
--- /dev/null
+++ b/features/stubs/behave/contrib/scenario_autoretry.pyi
@@ -0,0 +1,3 @@
+from behave.model import ScenarioOutline as ScenarioOutline
+
+def patch_scenario_with_autoretry(scenario, max_attempts: int = 3): ...
diff --git a/features/stubs/behave/contrib/steps/__init__.pyi b/features/stubs/behave/contrib/steps/__init__.pyi
new file mode 100644
index 0000000..2bff7ba
--- /dev/null
+++ b/features/stubs/behave/contrib/steps/__init__.pyi
@@ -0,0 +1 @@
+from behave.formatter.steps import StepsUsageFormatter as StepsUsageFormatter
diff --git a/features/stubs/behave/contrib/substep_dirs.pyi b/features/stubs/behave/contrib/substep_dirs.pyi
new file mode 100644
index 0000000..e69de29
diff --git a/features/stubs/behave/fixture.pyi b/features/stubs/behave/fixture.pyi
new file mode 100644
index 0000000..5709446
--- /dev/null
+++ b/features/stubs/behave/fixture.pyi
@@ -0,0 +1,16 @@
+from _typeshed import Incomplete
+
+def iscoroutinefunction(func): ...
+def is_context_manager(func): ...
+
+class InvalidFixtureError(RuntimeError): ...
+
+def use_fixture(fixture_func, context, *fixture_args, **fixture_kwargs): ...
+def use_fixture_by_tag(tag, context, fixture_registry): ...
+def fixture_call_params(fixture_func, *args, **kwargs): ...
+def use_composite_fixture_with(context, fixture_funcs_with_params): ...
+def fixture(
+    func: Incomplete | None = None,
+    name: Incomplete | None = None,
+    pattern: Incomplete | None = None,
+): ...
diff --git a/features/stubs/behave/formatter/__init__.pyi b/features/stubs/behave/formatter/__init__.pyi
new file mode 100644
index 0000000..e69de29
diff --git a/features/stubs/behave/formatter/_builtins.pyi b/features/stubs/behave/formatter/_builtins.pyi
new file mode 100644
index 0000000..a9366a6
--- /dev/null
+++ b/features/stubs/behave/formatter/_builtins.pyi
@@ -0,0 +1 @@
+def setup_formatters() -> None: ...
diff --git a/features/stubs/behave/formatter/_registry.pyi b/features/stubs/behave/formatter/_registry.pyi
new file mode 100644
index 0000000..17c68fe
--- /dev/null
+++ b/features/stubs/behave/formatter/_registry.pyi
@@ -0,0 +1,16 @@
+from behave.formatter.base import Formatter as Formatter
+from behave.formatter.base import StreamOpener as StreamOpener
+from behave.importer import LazyDict as LazyDict
+from behave.importer import LazyObject as LazyObject
+from behave.importer import load_module as load_module
+from behave.importer import parse_scoped_name as parse_scoped_name
+
+def format_iter(): ...
+def format_items(resolved: bool = False): ...
+def register_as(name, formatter_class) -> None: ...
+def register(formatter_class) -> None: ...
+def register_formats(formats) -> None: ...
+def load_formatter_class(scoped_class_name): ...
+def select_formatter_class(formatter_name): ...
+def is_formatter_valid(formatter_name): ...
+def make_formatters(config, stream_openers): ...
diff --git a/features/stubs/behave/formatter/ansi_escapes.pyi b/features/stubs/behave/formatter/ansi_escapes.pyi
new file mode 100644
index 0000000..3a04151
--- /dev/null
+++ b/features/stubs/behave/formatter/ansi_escapes.pyi
@@ -0,0 +1,12 @@
+from _typeshed import Incomplete
+
+colors: Incomplete
+aliases: Incomplete
+escapes: Incomplete
+new_aliases: Incomplete
+arg_alias: Incomplete
+arg_seq: Incomplete
+
+def up(n): ...
+def strip_escapes(text): ...
+def use_ansi_escape_colorbold_composites() -> None: ...
diff --git a/features/stubs/behave/formatter/base.pyi b/features/stubs/behave/formatter/base.pyi
new file mode 100644
index 0000000..2a36b85
--- /dev/null
+++ b/features/stubs/behave/formatter/base.pyi
@@ -0,0 +1,42 @@
+from _typeshed import Incomplete
+from behave.textutil import select_best_encoding as select_best_encoding
+
+class StreamOpener:
+    default_encoding: Incomplete
+    name: Incomplete
+    stream: Incomplete
+    encoding: Incomplete
+    should_close_stream: Incomplete
+    def __init__(
+        self,
+        filename: Incomplete | None = None,
+        stream: Incomplete | None = None,
+        encoding: Incomplete | None = None,
+    ) -> None: ...
+    @staticmethod
+    def ensure_dir_exists(directory) -> None: ...
+    @classmethod
+    def ensure_stream_with_encoder(cls, stream, encoding: Incomplete | None = None): ...
+    def open(self): ...
+    def close(self): ...
+
+class Formatter:
+    name: Incomplete
+    description: Incomplete
+    stream_opener: Incomplete
+    stream: Incomplete
+    config: Incomplete
+    def __init__(self, stream_opener, config) -> None: ...
+    @property
+    def stdout_mode(self): ...
+    def open(self): ...
+    def uri(self, uri) -> None: ...
+    def feature(self, feature) -> None: ...
+    def background(self, background) -> None: ...
+    def scenario(self, scenario) -> None: ...
+    def step(self, step) -> None: ...
+    def match(self, match) -> None: ...
+    def result(self, step) -> None: ...
+    def eof(self) -> None: ...
+    def close(self) -> None: ...
+    def close_stream(self) -> None: ...
diff --git a/features/stubs/behave/formatter/formatters.pyi b/features/stubs/behave/formatter/formatters.pyi
new file mode 100644
index 0000000..6d7fd46
--- /dev/null
+++ b/features/stubs/behave/formatter/formatters.pyi
@@ -0,0 +1,4 @@
+def register_as(formatter_class, name) -> None: ...
+def register(formatter_class) -> None: ...
+def get_formatter(config, stream_openers): ...
+def setup_formatters() -> None: ...
diff --git a/features/stubs/behave/formatter/json.pyi b/features/stubs/behave/formatter/json.pyi
new file mode 100644
index 0000000..1e4a860
--- /dev/null
+++ b/features/stubs/behave/formatter/json.pyi
@@ -0,0 +1,44 @@
+from _typeshed import Incomplete
+from behave.formatter.base import Formatter as Formatter
+from behave.model_core import Status as Status
+
+class JSONFormatter(Formatter):
+    name: str
+    description: str
+    dumps_kwargs: Incomplete
+    split_text_into_lines: bool
+    json_number_types: Incomplete
+    json_scalar_types: Incomplete
+    stream: Incomplete
+    feature_count: int
+    current_feature: Incomplete
+    current_feature_data: Incomplete
+    current_scenario: Incomplete
+    def __init__(self, stream_opener, config) -> None: ...
+    def reset(self) -> None: ...
+    def uri(self, uri) -> None: ...
+    def feature(self, feature) -> None: ...
+    def background(self, background) -> None: ...
+    def scenario(self, scenario) -> None: ...
+    @classmethod
+    def make_table(cls, table): ...
+    def step(self, step) -> None: ...
+    def match(self, match) -> None: ...
+    def result(self, step) -> None: ...
+    def embedding(self, mime_type, data) -> None: ...
+    def eof(self) -> None: ...
+    def close(self) -> None: ...
+    def add_feature_element(self, element): ...
+    @property
+    def current_feature_element(self): ...
+    def update_status_data(self) -> None: ...
+    def finish_current_scenario(self) -> None: ...
+    def write_json_header(self) -> None: ...
+    def write_json_footer(self) -> None: ...
+    def write_json_feature(self, feature_data) -> None: ...
+    def write_json_feature_separator(self) -> None: ...
+
+class PrettyJSONFormatter(JSONFormatter):
+    name: str
+    description: str
+    dumps_kwargs: Incomplete
diff --git a/features/stubs/behave/formatter/null.pyi b/features/stubs/behave/formatter/null.pyi
new file mode 100644
index 0000000..2347f7f
--- /dev/null
+++ b/features/stubs/behave/formatter/null.pyi
@@ -0,0 +1,5 @@
+from behave.formatter.base import Formatter as Formatter
+
+class NullFormatter(Formatter):
+    name: str
+    description: str
diff --git a/features/stubs/behave/formatter/plain.pyi b/features/stubs/behave/formatter/plain.pyi
new file mode 100644
index 0000000..5732bef
--- /dev/null
+++ b/features/stubs/behave/formatter/plain.pyi
@@ -0,0 +1,41 @@
+from _typeshed import Incomplete
+from behave.formatter.base import Formatter as Formatter
+from behave.model_describe import ModelPrinter as ModelPrinter
+from behave.textutil import make_indentation as make_indentation
+
+class PlainFormatter(Formatter):
+    name: str
+    description: str
+    SHOW_MULTI_LINE: bool
+    SHOW_TAGS: bool
+    SHOW_ALIGNED_KEYWORDS: bool
+    DEFAULT_INDENT_SIZE: int
+    RAISE_OUTPUT_ERRORS: bool
+    steps: Incomplete
+    show_timings: Incomplete
+    show_multiline: Incomplete
+    show_aligned_keywords: Incomplete
+    show_tags: Incomplete
+    indent_size: Incomplete
+    stream: Incomplete
+    printer: Incomplete
+    def __init__(self, stream_opener, config, **kwargs) -> None: ...
+    @property
+    def multiline_indentation(self): ...
+    def reset_steps(self) -> None: ...
+    def write_tags(self, tags, indent: Incomplete | None = None) -> None: ...
+    def feature(self, feature) -> None: ...
+    def background(self, background) -> None: ...
+    def scenario(self, scenario) -> None: ...
+    def step(self, step) -> None: ...
+    def result(self, step) -> None: ...
+    def eof(self) -> None: ...
+    def doc_string(self, doc_string) -> None: ...
+    def table(self, table) -> None: ...
+
+class Plain0Formatter(PlainFormatter):
+    name: str
+    description: str
+    SHOW_MULTI_LINE: bool
+    SHOW_TAGS: bool
+    SHOW_ALIGNED_KEYWORDS: bool
diff --git a/features/stubs/behave/formatter/pretty.pyi b/features/stubs/behave/formatter/pretty.pyi
new file mode 100644
index 0000000..139967a
--- /dev/null
+++ b/features/stubs/behave/formatter/pretty.pyi
@@ -0,0 +1,62 @@
+from _typeshed import Incomplete
+from behave.formatter.ansi_escapes import escapes as escapes
+from behave.formatter.ansi_escapes import up as up
+from behave.formatter.base import Formatter as Formatter
+from behave.model_core import Status as Status
+from behave.model_describe import escape_cell as escape_cell
+from behave.model_describe import escape_triple_quotes as escape_triple_quotes
+from behave.textutil import indent as indent
+
+DEFAULT_WIDTH: int
+DEFAULT_HEIGHT: int
+
+def get_terminal_size(): ...
+
+class MonochromeFormat:
+    def text(self, text): ...
+
+class ColorFormat:
+    status: Incomplete
+    def __init__(self, status) -> None: ...
+    def text(self, text): ...
+
+class PrettyFormatter(Formatter):
+    name: str
+    description: str
+    stream: Incomplete
+    monochrome: Incomplete
+    show_source: Incomplete
+    show_timings: Incomplete
+    show_multiline: Incomplete
+    formats: Incomplete
+    display_width: Incomplete
+    steps: Incomplete
+    statement: Incomplete
+    indentations: Incomplete
+    step_lines: int
+    def __init__(self, stream_opener, config) -> None: ...
+    def reset(self) -> None: ...
+    def uri(self, uri) -> None: ...
+    def feature(self, feature) -> None: ...
+    def background(self, background) -> None: ...
+    def scenario(self, scenario) -> None: ...
+    def replay(self) -> None: ...
+    def step(self, step) -> None: ...
+    def match(self, match) -> None: ...
+    def result(self, step) -> None: ...
+    def arg_format(self, key): ...
+    def format(self, key): ...
+    def eof(self) -> None: ...
+    def table(self, table) -> None: ...
+    def doc_string(self, doc_string) -> None: ...
+    def color(self, cell, statuses, _color): ...
+    def indented_text(self, text, proceed): ...
+    def calculate_location_indentations(self) -> None: ...
+    def print_statement(self) -> None: ...
+    def print_steps(self) -> None: ...
+    def print_step(self, status, arguments, location, proceed) -> None: ...
+    def print_tags(self, tags, indentation) -> None: ...
+    def print_comments(self, comments, indentation) -> None: ...
+    def print_description(
+        self, description, indentation, newline: bool = True
+    ) -> None: ...
diff --git a/features/stubs/behave/formatter/progress.pyi b/features/stubs/behave/formatter/progress.pyi
new file mode 100644
index 0000000..7a31b65
--- /dev/null
+++ b/features/stubs/behave/formatter/progress.pyi
@@ -0,0 +1,53 @@
+from _typeshed import Incomplete
+from behave.formatter.base import Formatter as Formatter
+from behave.model_core import Status as Status
+
+class ProgressFormatterBase(Formatter):
+    dot_status: Incomplete
+    show_timings: bool
+    stream: Incomplete
+    steps: Incomplete
+    failures: Incomplete
+    current_feature: Incomplete
+    current_scenario: Incomplete
+    def __init__(self, stream_opener, config) -> None: ...
+    def reset(self) -> None: ...
+    def feature(self, feature) -> None: ...
+    def background(self, background) -> None: ...
+    def scenario(self, scenario) -> None: ...
+    def step(self, step) -> None: ...
+    def result(self, step) -> None: ...
+    def eof(self) -> None: ...
+    def report_step_progress(self, step) -> None: ...
+    def report_scenario_progress(self) -> None: ...
+    def report_feature_completed(self) -> None: ...
+    def report_scenario_completed(self) -> None: ...
+    def report_feature_duration(self) -> None: ...
+    def report_scenario_duration(self) -> None: ...
+    def report_failures(self) -> None: ...
+
+class ScenarioProgressFormatter(ProgressFormatterBase):
+    name: str
+    description: str
+    def report_scenario_progress(self) -> None: ...
+    def report_feature_completed(self) -> None: ...
+
+class StepProgressFormatter(ProgressFormatterBase):
+    name: str
+    description: str
+    def report_step_progress(self, step) -> None: ...
+    def report_feature_completed(self) -> None: ...
+
+class ScenarioStepProgressFormatter(StepProgressFormatter):
+    name: str
+    description: str
+    indent_size: int
+    scenario_prefix: Incomplete
+    current_feature: Incomplete
+    def feature(self, feature) -> None: ...
+    current_scenario: Incomplete
+    def scenario(self, scenario) -> None: ...
+    def report_feature_completed(self) -> None: ...
+    failures: Incomplete
+    def report_scenario_completed(self) -> None: ...
+    def report_failures(self) -> None: ...
diff --git a/features/stubs/behave/formatter/rerun.pyi b/features/stubs/behave/formatter/rerun.pyi
new file mode 100644
index 0000000..673e064
--- /dev/null
+++ b/features/stubs/behave/formatter/rerun.pyi
@@ -0,0 +1,18 @@
+from _typeshed import Incomplete
+from behave.formatter.base import Formatter as Formatter
+from behave.model_core import Status as Status
+
+class RerunFormatter(Formatter):
+    name: str
+    description: str
+    show_timestamp: bool
+    show_failed_scenarios_descriptions: bool
+    failed_scenarios: Incomplete
+    current_feature: Incomplete
+    def __init__(self, stream_opener, config) -> None: ...
+    def reset(self) -> None: ...
+    def feature(self, feature) -> None: ...
+    def eof(self) -> None: ...
+    stream: Incomplete
+    def close(self) -> None: ...
+    def report_scenario_failures(self) -> None: ...
diff --git a/features/stubs/behave/formatter/sphinx_steps.pyi b/features/stubs/behave/formatter/sphinx_steps.pyi
new file mode 100644
index 0000000..9e8969c
--- /dev/null
+++ b/features/stubs/behave/formatter/sphinx_steps.pyi
@@ -0,0 +1,74 @@
+from _typeshed import Incomplete
+from behave.formatter import sphinx_util as sphinx_util
+from behave.formatter.steps import AbstractStepsFormatter as AbstractStepsFormatter
+from behave.model import Table as Table
+
+has_docutils: bool
+
+class StepsModule:
+    module_name: Incomplete
+    step_definitions: Incomplete
+    def __init__(
+        self, module_name, step_definitions: Incomplete | None = None
+    ) -> None: ...
+    @property
+    def name(self): ...
+    @property
+    def filename(self): ...
+    @property
+    def module(self): ...
+    @property
+    def module_doc(self): ...
+    def append(self, step_definition) -> None: ...
+
+class SphinxStepsDocumentGenerator:
+    default_step_definition_doc: str
+    shows_step_module_info: bool
+    shows_step_module_overview: bool
+    make_step_index_entries: bool
+    make_step_labels = has_docutils
+    document_separator: Incomplete
+    step_document_prefix: str
+    step_heading_prefix: str
+    step_definitions: Incomplete
+    destdir: Incomplete
+    stream: Incomplete
+    document: Incomplete
+    def __init__(
+        self,
+        step_definitions,
+        destdir: Incomplete | None = None,
+        stream: Incomplete | None = None,
+    ) -> None: ...
+    @property
+    def stdout_mode(self): ...
+    @staticmethod
+    def describe_step_definition(
+        step_definition, step_type: Incomplete | None = None
+    ): ...
+    def ensure_destdir_exists(self) -> None: ...
+    def ensure_document_is_closed(self) -> None: ...
+    def discover_step_modules(self): ...
+    def create_document(self, filename): ...
+    def write_docs(self): ...
+    def write_step_module_index(
+        self, step_modules, filename: str = "index.rst"
+    ) -> None: ...
+    def write_step_module(self, step_module) -> None: ...
+    def write_step_module_overview(self, step_definitions) -> None: ...
+    @staticmethod
+    def make_step_definition_index_id(step): ...
+    def make_step_definition_doc(self, step): ...
+    def write_step_definition(self, step) -> None: ...
+
+class SphinxStepsFormatter(AbstractStepsFormatter):
+    name: str
+    description: str
+    doc_generator_class = SphinxStepsDocumentGenerator
+    destdir: Incomplete
+    def __init__(self, stream_opener, config) -> None: ...
+    @property
+    def step_definitions(self): ...
+    def close(self) -> None: ...
+    def create_document_generator(self): ...
+    def report(self) -> None: ...
diff --git a/features/stubs/behave/formatter/sphinx_util.pyi b/features/stubs/behave/formatter/sphinx_util.pyi
new file mode 100644
index 0000000..7764d47
--- /dev/null
+++ b/features/stubs/behave/formatter/sphinx_util.pyi
@@ -0,0 +1,28 @@
+from _typeshed import Incomplete
+from behave.textutil import compute_words_maxsize as compute_words_maxsize
+
+class DocumentWriter:
+    heading_styles: Incomplete
+    default_encoding: str
+    default_toctree_title: str
+    stream: Incomplete
+    filename: Incomplete
+    should_close: Incomplete
+    def __init__(
+        self, stream, filename: Incomplete | None = None, should_close: bool = True
+    ) -> None: ...
+    @classmethod
+    def open(cls, filename, encoding: Incomplete | None = None): ...
+    def write(self, *args): ...
+    def close(self) -> None: ...
+    def write_heading(
+        self,
+        heading,
+        level: int = 0,
+        index_id: Incomplete | None = None,
+        label: Incomplete | None = None,
+    ) -> None: ...
+    def write_toctree(
+        self, entries, title: Incomplete | None = None, maxdepth: int = 2
+    ) -> None: ...
+    def write_table(self, table) -> None: ...
diff --git a/features/stubs/behave/formatter/steps.pyi b/features/stubs/behave/formatter/steps.pyi
new file mode 100644
index 0000000..894fb22
--- /dev/null
+++ b/features/stubs/behave/formatter/steps.pyi
@@ -0,0 +1,77 @@
+from _typeshed import Incomplete
+from behave import i18n as i18n
+from behave.formatter.base import Formatter as Formatter
+from behave.step_registry import StepRegistry as StepRegistry
+from behave.step_registry import registry as registry
+from behave.textutil import compute_words_maxsize as compute_words_maxsize
+from behave.textutil import indent as indent
+from behave.textutil import make_indentation as make_indentation
+
+class AbstractStepsFormatter(Formatter):
+    step_types: Incomplete
+    step_registry: Incomplete
+    current_feature: Incomplete
+    shows_location: Incomplete
+    def __init__(self, stream_opener, config) -> None: ...
+    def reset(self) -> None: ...
+    def discover_step_definitions(self) -> None: ...
+    def feature(self, feature) -> None: ...
+    def eof(self) -> None: ...
+    stream: Incomplete
+    def close(self) -> None: ...
+    def report(self) -> None: ...
+    def describe_step_definition(
+        self, step_definition, step_type: Incomplete | None = None
+    ): ...
+
+class StepsFormatter(AbstractStepsFormatter):
+    name: str
+    description: str
+    shows_location: bool
+    min_location_column: int
+    def report(self) -> None: ...
+    def report_steps_by_type(self) -> None: ...
+
+class StepsDocFormatter(AbstractStepsFormatter):
+    name: str
+    description: str
+    shows_location: bool
+    shows_function_name: bool
+    ordered_by_location: bool
+    doc_prefix: Incomplete
+    def report(self) -> None: ...
+    def report_step_definition_docs(self) -> None: ...
+    def write_step_definition(self, step_definition) -> None: ...
+
+class StepsCatalogFormatter(StepsDocFormatter):
+    name: str
+    description: str
+    shows_location: bool
+    shows_function_name: bool
+    ordered_by_location: bool
+    doc_prefix: Incomplete
+    def describe_step_definition(
+        self, step_definition, step_type: Incomplete | None = None
+    ): ...
+
+class StepsUsageFormatter(AbstractStepsFormatter):
+    name: str
+    description: str
+    doc_prefix: Incomplete
+    min_location_column: int
+    step_usage_database: Incomplete
+    undefined_steps: Incomplete
+    def __init__(self, stream_opener, config) -> None: ...
+    def reset(self) -> None: ...
+    def get_step_type_for_step_definition(self, step_definition): ...
+    def select_unused_step_definitions(self): ...
+    def update_usage_database(self, step_definition, step) -> None: ...
+    def update_usage_database_for_step(self, step) -> None: ...
+    def update_usage_database_for_feature(self, feature) -> None: ...
+    def feature(self, feature) -> None: ...
+    def report(self) -> None: ...
+    def report_used_step_definitions(self): ...
+    def report_unused_step_definitions(self): ...
+    def report_undefined_steps(self) -> None: ...
+
+def steps_contain(steps, step): ...
diff --git a/features/stubs/behave/formatter/tags.pyi b/features/stubs/behave/formatter/tags.pyi
new file mode 100644
index 0000000..a50707c
--- /dev/null
+++ b/features/stubs/behave/formatter/tags.pyi
@@ -0,0 +1,33 @@
+from _typeshed import Incomplete
+from behave.formatter.base import Formatter as Formatter
+from behave.textutil import compute_words_maxsize as compute_words_maxsize
+
+class AbstractTagsFormatter(Formatter):
+    with_tag_inheritance: bool
+    tag_counts: Incomplete
+    def __init__(self, stream_opener, config) -> None: ...
+    def uri(self, uri) -> None: ...
+    def feature(self, feature) -> None: ...
+    def scenario(self, scenario) -> None: ...
+    stream: Incomplete
+    def close(self) -> None: ...
+    def record_tags(self, tags, model_element) -> None: ...
+    def report_tags(self) -> None: ...
+
+class TagsFormatter(AbstractTagsFormatter):
+    name: str
+    description: str
+    with_tag_inheritance: bool
+    show_ordered_by_usage: bool
+    def report_tags(self) -> None: ...
+    @staticmethod
+    def get_tag_count_details(tag_count): ...
+    def report_tag_counts(self) -> None: ...
+    def report_tag_counts_by_usage(self): ...
+
+class TagsLocationFormatter(AbstractTagsFormatter):
+    name: str
+    description: str
+    with_tag_inheritance: bool
+    def report_tags(self) -> None: ...
+    def report_tags_by_locations(self) -> None: ...
diff --git a/features/stubs/behave/i18n.pyi b/features/stubs/behave/i18n.pyi
new file mode 100644
index 0000000..08e2933
--- /dev/null
+++ b/features/stubs/behave/i18n.pyi
@@ -0,0 +1,3 @@
+from _typeshed import Incomplete
+
+languages: Incomplete
diff --git a/features/stubs/behave/importer.pyi b/features/stubs/behave/importer.pyi
new file mode 100644
index 0000000..c7ff01b
--- /dev/null
+++ b/features/stubs/behave/importer.pyi
@@ -0,0 +1,20 @@
+from _typeshed import Incomplete
+from behave._types import Unknown as Unknown
+
+def parse_scoped_name(scoped_name): ...
+def load_module(module_name): ...
+
+class LazyObject:
+    module_name: Incomplete
+    object_name: Incomplete
+    resolved_object: Incomplete
+    def __init__(self, module_name, object_name: Incomplete | None = None) -> None: ...
+    def __get__(
+        self, obj: Incomplete | None = None, type: Incomplete | None = None
+    ): ...
+    def __set__(self, obj, value) -> None: ...
+    def get(self): ...
+
+class LazyDict(dict):
+    def __getitem__(self, key): ...
+    def load_all(self, strict: bool = False) -> None: ...
diff --git a/features/stubs/behave/json_parser.pyi b/features/stubs/behave/json_parser.pyi
new file mode 100644
index 0000000..0304048
--- /dev/null
+++ b/features/stubs/behave/json_parser.pyi
@@ -0,0 +1,22 @@
+from _typeshed import Incomplete
+from behave import model as model
+from behave.model_core import Status as Status
+
+def parse(json_filename, encoding: str = "UTF-8"): ...
+
+class JsonParser:
+    current_scenario_outline: Incomplete
+    def __init__(self) -> None: ...
+    def parse_features(self, json_data): ...
+    def parse_feature(self, json_feature): ...
+    def add_feature_element(self, feature, json_element) -> None: ...
+    def parse_background(self, json_element): ...
+    def parse_scenario(self, json_element): ...
+    def parse_scenario_outline(self, json_element): ...
+    def parse_steps(self, json_steps): ...
+    def parse_step(self, json_element): ...
+    @staticmethod
+    def add_step_result(step, json_result) -> None: ...
+    @staticmethod
+    def parse_table(json_table): ...
+    def parse_examples(self, json_element): ...
diff --git a/features/stubs/behave/log_capture.pyi b/features/stubs/behave/log_capture.pyi
new file mode 100644
index 0000000..9e56209
--- /dev/null
+++ b/features/stubs/behave/log_capture.pyi
@@ -0,0 +1,29 @@
+from logging.handlers import BufferingHandler
+
+from _typeshed import Incomplete
+
+class RecordFilter:
+    include: Incomplete
+    exclude: Incomplete
+    def __init__(self, names) -> None: ...
+    def filter(self, record): ...
+
+class LoggingCapture(BufferingHandler):
+    config: Incomplete
+    old_handlers: Incomplete
+    old_level: Incomplete
+    level: Incomplete
+    def __init__(self, config, level: Incomplete | None = None) -> None: ...
+    def __bool__(self) -> bool: ...
+    def flush(self) -> None: ...
+    buffer: Incomplete
+    def truncate(self) -> None: ...
+    def getvalue(self): ...
+    def find_event(self, pattern): ...
+    def any_errors(self): ...
+    def inveigle(self) -> None: ...
+    def abandon(self) -> None: ...
+
+MemoryHandler = LoggingCapture
+
+def capture(*args, **kw): ...
diff --git a/features/stubs/behave/matchers.pyi b/features/stubs/behave/matchers.pyi
new file mode 100644
index 0000000..380f2f9
--- /dev/null
+++ b/features/stubs/behave/matchers.pyi
@@ -0,0 +1,82 @@
+from _typeshed import Incomplete
+from behave._types import ChainedExceptionUtil as ChainedExceptionUtil
+from behave._types import ExceptionUtil as ExceptionUtil
+from behave.model_core import Argument as Argument
+from behave.model_core import FileLocation as FileLocation
+from behave.model_core import Replayable as Replayable
+
+class StepParseError(ValueError):
+    def __init__(
+        self, text: Incomplete | None = None, exc_cause: Incomplete | None = None
+    ) -> None: ...
+
+class Match(Replayable):
+    type: str
+    func: Incomplete
+    arguments: Incomplete
+    location: Incomplete
+    def __init__(self, func, arguments: Incomplete | None = None) -> None: ...
+    def __eq__(self, other): ...
+    def with_arguments(self, arguments): ...
+    def run(self, context) -> None: ...
+    @staticmethod
+    def make_location(step_function): ...
+
+class NoMatch(Match):
+    func: Incomplete
+    arguments: Incomplete
+    location: Incomplete
+    def __init__(self) -> None: ...
+
+class MatchWithError(Match):
+    stored_error: Incomplete
+    def __init__(self, func, error) -> None: ...
+    def run(self, context) -> None: ...
+
+class Matcher:
+    schema: str
+    func: Incomplete
+    pattern: Incomplete
+    step_type: Incomplete
+    def __init__(self, func, pattern, step_type: Incomplete | None = None) -> None: ...
+    @property
+    def string(self): ...
+    @property
+    def location(self): ...
+    @property
+    def regex_pattern(self): ...
+    def describe(self, schema: Incomplete | None = None): ...
+    def check_match(self, step) -> None: ...
+    def match(self, step): ...
+
+class ParseMatcher(Matcher):
+    custom_types: Incomplete
+    parser_class: Incomplete
+    parser: Incomplete
+    def __init__(self, func, pattern, step_type: Incomplete | None = None) -> None: ...
+    @property
+    def regex_pattern(self): ...
+    def check_match(self, step): ...
+
+class CFParseMatcher(ParseMatcher):
+    parser_class: Incomplete
+
+def register_type(**kw) -> None: ...
+
+class RegexMatcher(Matcher):
+    regex: Incomplete
+    def __init__(self, func, pattern, step_type: Incomplete | None = None) -> None: ...
+    def check_match(self, step): ...
+
+class SimplifiedRegexMatcher(RegexMatcher):
+    pattern: Incomplete
+    def __init__(self, func, pattern, step_type: Incomplete | None = None) -> None: ...
+
+class CucumberRegexMatcher(RegexMatcher): ...
+
+matcher_mapping: Incomplete
+current_matcher = ParseMatcher
+
+def use_step_matcher(name) -> None: ...
+def step_matcher(name) -> None: ...
+def get_matcher(func, pattern): ...
diff --git a/features/stubs/behave/model.pyi b/features/stubs/behave/model.pyi
new file mode 100644
index 0000000..94f3822
--- /dev/null
+++ b/features/stubs/behave/model.pyi
@@ -0,0 +1,252 @@
+import typing
+
+import six
+from _typeshed import Incomplete
+from behave.matchers import NoMatch as NoMatch
+from behave.model_core import BasicStatement as BasicStatement
+from behave.model_core import Replayable as Replayable
+from behave.model_core import Status as Status
+from behave.model_core import TagAndStatusStatement as TagAndStatusStatement
+from behave.model_core import TagStatement as TagStatement
+
+class Feature(TagAndStatusStatement, Replayable):
+    type: str
+    description: Incomplete
+    scenarios: Incomplete
+    background: Incomplete
+    language: Incomplete
+    parser: Incomplete
+    hook_failed: bool
+    def __init__(
+        self,
+        filename,
+        line,
+        keyword,
+        name,
+        tags: Incomplete | None = None,
+        description: Incomplete | None = None,
+        scenarios: Incomplete | None = None,
+        background: Incomplete | None = None,
+        language: Incomplete | None = None,
+    ) -> None: ...
+    def reset(self) -> None: ...
+    def __iter__(self): ...
+    def add_scenario(self, scenario) -> None: ...
+    def compute_status(self): ...
+    @property
+    def duration(self): ...
+    def walk_scenarios(self, with_outlines: bool = False): ...
+    def should_run(self, config: Incomplete | None = None): ...
+    def should_run_with_tags(self, tag_expression): ...
+    def mark_skipped(self) -> None: ...
+    should_skip: bool
+    skip_reason: Incomplete
+    def skip(
+        self, reason: Incomplete | None = None, require_not_executed: bool = False
+    ) -> None: ...
+    def run(self, runner): ...
+
+class Background(BasicStatement, Replayable):
+    type: str
+    steps: Incomplete
+    def __init__(
+        self, filename, line, keyword, name, steps: Incomplete | None = None
+    ) -> None: ...
+    def __iter__(self): ...
+    @property
+    def duration(self): ...
+
+class Scenario(TagAndStatusStatement, Replayable):
+    type: str
+    continue_after_failed_step: bool
+    description: Incomplete
+    steps: Incomplete
+    background: Incomplete
+    feature: Incomplete
+    hook_failed: bool
+    was_dry_run: bool
+    def __init__(
+        self,
+        filename,
+        line,
+        keyword,
+        name,
+        tags: Incomplete | None = None,
+        steps: Incomplete | None = None,
+        description: Incomplete | None = None,
+    ) -> None: ...
+    def reset(self) -> None: ...
+    @property
+    def background_steps(self): ...
+    @property
+    def all_steps(self): ...
+    def __iter__(self): ...
+    def compute_status(self): ...
+    @property
+    def duration(self): ...
+    @property
+    def effective_tags(self): ...
+    def should_run(self, config: Incomplete | None = None): ...
+    def should_run_with_tags(self, tag_expression): ...
+    def should_run_with_name_select(self, config): ...
+    def mark_skipped(self) -> None: ...
+    should_skip: bool
+    skip_reason: Incomplete
+    def skip(
+        self, reason: Incomplete | None = None, require_not_executed: bool = False
+    ) -> None: ...
+    captured: Incomplete
+    def run(self, runner): ...
+
+class ScenarioOutlineBuilder:
+    annotation_schema: Incomplete
+    def __init__(self, annotation_schema) -> None: ...
+    @staticmethod
+    def render_template(
+        text, row: Incomplete | None = None, params: Incomplete | None = None
+    ): ...
+    name: Incomplete
+    index: Incomplete
+    id: Incomplete
+    def make_scenario_name(
+        self, outline_name, example, row, params: Incomplete | None = None
+    ): ...
+    @classmethod
+    def make_row_tags(cls, outline_tags, row, params: Incomplete | None = None): ...
+    @classmethod
+    def make_step_for_row(cls, outline_step, row, params: Incomplete | None = None): ...
+    def build_scenarios(self, scenario_outline): ...
+
+class ScenarioOutline(Scenario):
+    type: str
+    annotation_schema: str
+    examples: Incomplete
+    def __init__(
+        self,
+        filename,
+        line,
+        keyword,
+        name,
+        tags: Incomplete | None = None,
+        steps: Incomplete | None = None,
+        examples: Incomplete | None = None,
+        description: Incomplete | None = None,
+    ) -> None: ...
+    def reset(self) -> None: ...
+    @property
+    def scenarios(self): ...
+    def __iter__(self): ...
+    def compute_status(self): ...
+    @property
+    def duration(self): ...
+    def should_run_with_tags(self, tag_expression): ...
+    def should_run_with_name_select(self, config): ...
+    def mark_skipped(self) -> None: ...
+    should_skip: bool
+    def skip(
+        self, reason: Incomplete | None = None, require_not_executed: bool = False
+    ) -> None: ...
+    def run(self, runner): ...
+
+class Examples(TagStatement, Replayable):
+    type: str
+    table: Incomplete
+    index: Incomplete
+    def __init__(
+        self,
+        filename,
+        line,
+        keyword,
+        name,
+        tags: Incomplete | None = None,
+        table: Incomplete | None = None,
+    ) -> None: ...
+
+class Step(BasicStatement, Replayable):
+    type: str
+    step_type: Incomplete
+    text: Incomplete
+    table: Incomplete
+    status: Incomplete
+    hook_failed: bool
+    duration: int
+    def __init__(
+        self,
+        filename,
+        line,
+        keyword,
+        step_type,
+        name,
+        text: Incomplete | None = None,
+        table: Incomplete | None = None,
+    ) -> None: ...
+    def reset(self) -> None: ...
+    def __eq__(self, other): ...
+    def __hash__(self): ...
+    def set_values(self, table_row): ...
+    captured: Incomplete
+    error_message: Incomplete
+    def run(self, runner, quiet: bool = False, capture: bool = True): ...
+
+class Table(Replayable):
+    type: str
+    headings: Incomplete
+    line: Incomplete
+    rows: Incomplete
+    def __init__(
+        self, headings, line: Incomplete | None = None, rows: Incomplete | None = None
+    ) -> None: ...
+    def add_row(self, row, line: Incomplete | None = None) -> None: ...
+    def add_column(
+        self, column_name, values: Incomplete | None = None, default_value: str = ""
+    ): ...
+    def remove_column(self, column_name) -> None: ...
+    def remove_columns(self, column_names) -> None: ...
+    def has_column(self, column_name): ...
+    def get_column_index(self, column_name): ...
+    def require_column(self, column_name): ...
+    def require_columns(self, column_names) -> None: ...
+    def ensure_column_exists(self, column_name): ...
+    def __eq__(self, other): ...
+    def __ne__(self, other): ...
+    def __iter__(self): ...
+    def __getitem__(self, index): ...
+    def assert_equals(self, data) -> None: ...
+
+class Row:
+    headings: Incomplete
+    comments: Incomplete
+    cells: Incomplete
+    line: Incomplete
+    def __init__(
+        self,
+        headings,
+        cells,
+        line: Incomplete | None = None,
+        comments: Incomplete | None = None,
+    ) -> None: ...
+    def __getitem__(self, name): ...
+    def __eq__(self, other): ...
+    def __ne__(self, other): ...
+    def __len__(self) -> int: ...
+    def __iter__(self): ...
+    def items(self): ...
+    def get(self, key, default: Incomplete | None = None): ...
+    def as_dict(self): ...
+
+class Tag(six.text_type):
+    allowed_chars: str
+    quoting_chars: Incomplete
+    def __new__(cls, name, line): ...
+    @classmethod
+    def make_name(
+        cls, text, unescape: bool = False, allowed_chars: Incomplete | None = None
+    ): ...
+
+class Text(six.text_type):
+    def __new__(cls, value, content_type: str = "text/plain", line: int = 0): ...
+    def line_range(self): ...
+    def replace(self, old, new, SupportsIndex: typing.Any = -1): ...
+    def assert_equals(self, expected): ...
+
+def reset_model(model_elements) -> None: ...
diff --git a/features/stubs/behave/model_core.pyi b/features/stubs/behave/model_core.pyi
new file mode 100644
index 0000000..2f150ae
--- /dev/null
+++ b/features/stubs/behave/model_core.pyi
@@ -0,0 +1,97 @@
+from enum import Enum
+
+from _typeshed import Incomplete
+from behave.capture import Captured as Captured
+
+PLATFORM_WIN: Incomplete
+
+def posixpath_normalize(path): ...
+
+class Status(Enum):
+    untested: int
+    skipped: int
+    passed: int
+    failed: int
+    undefined: int
+    executing: int
+    def __eq__(self, other): ...
+    @classmethod
+    def from_name(cls, name): ...
+
+class Argument:
+    start: Incomplete
+    end: Incomplete
+    original: Incomplete
+    value: Incomplete
+    name: Incomplete
+    def __init__(
+        self, start, end, original, value, name: Incomplete | None = None
+    ) -> None: ...
+
+class FileLocation:
+    __pychecker__: str
+    filename: Incomplete
+    line: Incomplete
+    def __init__(self, filename, line: Incomplete | None = None) -> None: ...
+    def get(self): ...
+    def abspath(self): ...
+    def basename(self): ...
+    def dirname(self): ...
+    def relpath(self, start=...): ...
+    def exists(self): ...
+    def __eq__(self, other): ...
+    def __ne__(self, other): ...
+    def __lt__(self, other): ...
+    def __le__(self, other): ...
+    def __gt__(self, other): ...
+    def __ge__(self, other): ...
+    @classmethod
+    def for_function(cls, func, curdir: Incomplete | None = None): ...
+
+class BasicStatement:
+    location: Incomplete
+    keyword: Incomplete
+    name: Incomplete
+    captured: Incomplete
+    exception: Incomplete
+    exc_traceback: Incomplete
+    error_message: Incomplete
+    def __init__(self, filename, line, keyword, name) -> None: ...
+    @property
+    def filename(self): ...
+    @property
+    def line(self): ...
+    def reset(self) -> None: ...
+    def store_exception_context(self, exception) -> None: ...
+    def __hash__(self): ...
+    def __eq__(self, other): ...
+    def __lt__(self, other): ...
+    def __ne__(self, other): ...
+    def __le__(self, other): ...
+    def __gt__(self, other): ...
+    def __ge__(self, other): ...
+
+class TagStatement(BasicStatement):
+    tags: Incomplete
+    def __init__(self, filename, line, keyword, name, tags) -> None: ...
+    def should_run_with_tags(self, tag_expression): ...
+
+class TagAndStatusStatement(BasicStatement):
+    final_status: Incomplete
+    tags: Incomplete
+    should_skip: bool
+    skip_reason: Incomplete
+    def __init__(self, filename, line, keyword, name, tags) -> None: ...
+    def should_run_with_tags(self, tag_expression): ...
+    @property
+    def status(self): ...
+    def set_status(self, value) -> None: ...
+    def clear_status(self) -> None: ...
+    def reset(self) -> None: ...
+    def compute_status(self) -> None: ...
+
+class Replayable:
+    type: Incomplete
+    def replay(self, formatter) -> None: ...
+
+def unwrap_function(func, max_depth: int = 10): ...
diff --git a/features/stubs/behave/model_describe.pyi b/features/stubs/behave/model_describe.pyi
new file mode 100644
index 0000000..19b6e3c
--- /dev/null
+++ b/features/stubs/behave/model_describe.pyi
@@ -0,0 +1,17 @@
+from _typeshed import Incomplete
+from behave.textutil import indent as indent
+
+def escape_cell(cell): ...
+def escape_triple_quotes(text): ...
+
+class ModelDescriptor:
+    @staticmethod
+    def describe_table(table, indentation: Incomplete | None = None): ...
+    @staticmethod
+    def describe_docstring(doc_string, indentation: Incomplete | None = None): ...
+
+class ModelPrinter(ModelDescriptor):
+    stream: Incomplete
+    def __init__(self, stream) -> None: ...
+    def print_table(self, table, indentation: Incomplete | None = None) -> None: ...
+    def print_docstring(self, text, indentation: Incomplete | None = None) -> None: ...
diff --git a/features/stubs/behave/parser.pyi b/features/stubs/behave/parser.pyi
new file mode 100644
index 0000000..a5149eb
--- /dev/null
+++ b/features/stubs/behave/parser.pyi
@@ -0,0 +1,67 @@
+from _typeshed import Incomplete
+from behave import i18n as i18n
+from behave import model as model
+
+DEFAULT_LANGUAGE: str
+
+def parse_file(filename, language: Incomplete | None = None): ...
+def parse_feature(
+    data, language: Incomplete | None = None, filename: Incomplete | None = None
+): ...
+def parse_steps(
+    text, language: Incomplete | None = None, filename: Incomplete | None = None
+): ...
+def parse_tags(text): ...
+
+class ParserError(Exception):
+    line: Incomplete
+    line_text: Incomplete
+    filename: Incomplete
+    def __init__(
+        self,
+        message,
+        line,
+        filename: Incomplete | None = None,
+        line_text: Incomplete | None = None,
+    ) -> None: ...
+
+class Parser:
+    language: Incomplete
+    variant: Incomplete
+    state: str
+    line: int
+    last_step: Incomplete
+    multiline_start: Incomplete
+    multiline_leading: Incomplete
+    multiline_terminator: Incomplete
+    filename: Incomplete
+    feature: Incomplete
+    statement: Incomplete
+    tags: Incomplete
+    lines: Incomplete
+    table: Incomplete
+    examples: Incomplete
+    keywords: Incomplete
+    def __init__(
+        self, language: Incomplete | None = None, variant: Incomplete | None = None
+    ) -> None: ...
+    def reset(self) -> None: ...
+    def parse(self, data, filename: Incomplete | None = None): ...
+    def diagnose_feature_usage_error(self): ...
+    def diagnose_background_usage_error(self): ...
+    def diagnose_scenario_usage_error(self): ...
+    def diagnose_scenario_outline_usage_error(self): ...
+    def ask_parse_failure_oracle(self, line): ...
+    def action(self, line) -> None: ...
+    def action_init(self, line): ...
+    def subaction_detect_taggable_statement(self, line): ...
+    def action_feature(self, line): ...
+    def action_taggable_statement(self, line): ...
+    def action_scenario(self, line): ...
+    def action_steps(self, line): ...
+    def action_multiline(self, line): ...
+    def action_table(self, line): ...
+    def match_keyword(self, keyword, line): ...
+    def parse_tags(self, line): ...
+    def parse_step(self, line): ...
+    def parse_steps(self, text, filename: Incomplete | None = None): ...
diff --git a/features/stubs/behave/reporter/__init__.pyi b/features/stubs/behave/reporter/__init__.pyi
new file mode 100644
index 0000000..e69de29
diff --git a/features/stubs/behave/reporter/base.pyi b/features/stubs/behave/reporter/base.pyi
new file mode 100644
index 0000000..35eec83
--- /dev/null
+++ b/features/stubs/behave/reporter/base.pyi
@@ -0,0 +1,8 @@
+from _typeshed import Incomplete
+from behave.model_core import Status as Status
+
+class Reporter:
+    config: Incomplete
+    def __init__(self, config) -> None: ...
+    def feature(self, feature) -> None: ...
+    def end(self) -> None: ...
diff --git a/features/stubs/behave/reporter/junit.pyi b/features/stubs/behave/reporter/junit.pyi
new file mode 100644
index 0000000..153319f
--- /dev/null
+++ b/features/stubs/behave/reporter/junit.pyi
@@ -0,0 +1,55 @@
+from xml.etree import ElementTree
+
+from _typeshed import Incomplete
+from behave.formatter import ansi_escapes as ansi_escapes
+from behave.model import Scenario as Scenario
+from behave.model import ScenarioOutline as ScenarioOutline
+from behave.model import Step as Step
+from behave.model_core import Status as Status
+from behave.model_describe import ModelDescriptor as ModelDescriptor
+from behave.reporter.base import Reporter as Reporter
+from behave.textutil import indent as indent
+from behave.textutil import make_indentation as make_indentation
+from behave.userdata import UserDataNamespace as UserDataNamespace
+
+def CDATA(text: Incomplete | None = None): ...
+
+class ElementTreeWithCDATA(ElementTree.ElementTree): ...
+
+class FeatureReportData:
+    feature: Incomplete
+    filename: Incomplete
+    classname: Incomplete
+    testcases: Incomplete
+    counts_tests: int
+    counts_errors: int
+    counts_failed: int
+    counts_skipped: int
+    def __init__(
+        self, feature, filename, classname: Incomplete | None = None
+    ) -> None: ...
+    def reset(self) -> None: ...
+
+class JUnitReporter(Reporter):
+    userdata_scope: str
+    show_timings: bool
+    show_skipped_always: bool
+    show_timestamp: bool
+    show_hostname: bool
+    show_scenarios: bool
+    show_tags: bool
+    show_multiline: bool
+    def __init__(self, config) -> None: ...
+    def setup_with_userdata(self, userdata) -> None: ...
+    def make_feature_filename(self, feature): ...
+    @property
+    def show_skipped(self): ...
+    def feature(self, feature) -> None: ...
+    @staticmethod
+    def select_step_with_status(status, steps): ...
+    def describe_step(self, step): ...
+    @classmethod
+    def describe_tags(cls, tags): ...
+    def describe_scenario(self, scenario): ...
+
+def gethostname(): ...
diff --git a/features/stubs/behave/reporter/summary.pyi b/features/stubs/behave/reporter/summary.pyi
new file mode 100644
index 0000000..1d92b5e
--- /dev/null
+++ b/features/stubs/behave/reporter/summary.pyi
@@ -0,0 +1,25 @@
+from _typeshed import Incomplete
+from behave.formatter.base import StreamOpener as StreamOpener
+from behave.model import ScenarioOutline as ScenarioOutline
+from behave.model_core import Status as Status
+from behave.reporter.base import Reporter as Reporter
+
+optional_steps: Incomplete
+status_order: Incomplete
+
+def format_summary(statement_type, summary): ...
+
+class SummaryReporter(Reporter):
+    show_failed_scenarios: bool
+    output_stream_name: str
+    stream: Incomplete
+    feature_summary: Incomplete
+    scenario_summary: Incomplete
+    step_summary: Incomplete
+    duration: float
+    failed_scenarios: Incomplete
+    def __init__(self, config) -> None: ...
+    def feature(self, feature) -> None: ...
+    def end(self) -> None: ...
+    def process_scenario(self, scenario) -> None: ...
+    def process_scenario_outline(self, scenario_outline) -> None: ...
diff --git a/features/stubs/behave/runner.pyi b/features/stubs/behave/runner.pyi
new file mode 100644
index 0000000..b9d8121
--- /dev/null
+++ b/features/stubs/behave/runner.pyi
@@ -0,0 +1,88 @@
+from collections.abc import Generator
+
+from _typeshed import Incomplete
+from behave._types import ExceptionUtil as ExceptionUtil
+from behave.capture import CaptureController as CaptureController
+from behave.configuration import ConfigError as ConfigError
+from behave.formatter._registry import make_formatters as make_formatters
+from behave.runner_util import PathManager as PathManager
+from behave.runner_util import collect_feature_locations as collect_feature_locations
+from behave.runner_util import exec_file as exec_file
+from behave.runner_util import load_step_modules as load_step_modules
+from behave.runner_util import parse_features as parse_features
+
+class CleanupError(RuntimeError): ...
+class ContextMaskWarning(UserWarning): ...
+
+class Context:
+    BEHAVE: str
+    USER: str
+    FAIL_ON_CLEANUP_ERRORS: bool
+    feature: Incomplete
+    text: Incomplete
+    table: Incomplete
+    stdout_capture: Incomplete
+    stderr_capture: Incomplete
+    log_capture: Incomplete
+    fail_on_cleanup_errors: Incomplete
+    def __init__(self, runner) -> None: ...
+    @staticmethod
+    def ignore_cleanup_error(context, cleanup_func, exception) -> None: ...
+    @staticmethod
+    def print_cleanup_error(context, cleanup_func, exception) -> None: ...
+    def use_with_user_mode(self): ...
+    def user_mode(self): ...
+    def __getattr__(self, attr): ...
+    def __setattr__(self, attr, value) -> None: ...
+    def __delattr__(self, attr) -> None: ...
+    def __contains__(self, attr) -> bool: ...
+    def execute_steps(self, steps_text): ...
+    def add_cleanup(self, cleanup_func, *args, **kwargs) -> None: ...
+
+def use_context_with_mode(context, mode) -> Generator[None, None, None]: ...
+def scoped_context_layer(
+    context, layer_name: Incomplete | None = None
+) -> Generator[Incomplete, None, None]: ...
+def path_getrootdir(path): ...
+
+class ModelRunner:
+    config: Incomplete
+    features: Incomplete
+    hooks: Incomplete
+    formatters: Incomplete
+    undefined_steps: Incomplete
+    step_registry: Incomplete
+    capture_controller: Incomplete
+    context: Incomplete
+    feature: Incomplete
+    hook_failures: int
+    def __init__(
+        self,
+        config,
+        features: Incomplete | None = None,
+        step_registry: Incomplete | None = None,
+    ) -> None: ...
+    aborted: Incomplete
+    def run_hook(self, name, context, *args) -> None: ...
+    def setup_capture(self) -> None: ...
+    def start_capture(self) -> None: ...
+    def stop_capture(self) -> None: ...
+    def teardown_capture(self) -> None: ...
+    def run_model(self, features: Incomplete | None = None): ...
+    def run(self): ...
+
+class Runner(ModelRunner):
+    path_manager: Incomplete
+    base_dir: Incomplete
+    def __init__(self, config) -> None: ...
+    def setup_paths(self) -> None: ...
+    def before_all_default_hook(self, context) -> None: ...
+    def load_hooks(self, filename: Incomplete | None = None) -> None: ...
+    def load_step_definitions(
+        self, extra_step_paths: Incomplete | None = None
+    ) -> None: ...
+    def feature_locations(self): ...
+    def run(self): ...
+    context: Incomplete
+    formatters: Incomplete
+    def run_with_paths(self): ...
diff --git a/features/stubs/behave/runner_util.pyi b/features/stubs/behave/runner_util.pyi
new file mode 100644
index 0000000..770d339
--- /dev/null
+++ b/features/stubs/behave/runner_util.pyi
@@ -0,0 +1,62 @@
+from _typeshed import Incomplete
+from behave import parser as parser
+from behave.model_core import FileLocation as FileLocation
+from behave.textutil import ensure_stream_with_encoder as ensure_stream_with_encoder
+
+class FileNotFoundError(LookupError): ...
+class InvalidFileLocationError(LookupError): ...
+class InvalidFilenameError(ValueError): ...
+
+class FileLocationParser:
+    pattern: Incomplete
+    @classmethod
+    def parse(cls, text): ...
+
+class FeatureScenarioLocationCollector:
+    feature: Incomplete
+    filename: Incomplete
+    use_all_scenarios: bool
+    scenario_lines: Incomplete
+    all_scenarios: Incomplete
+    selected_scenarios: Incomplete
+    def __init__(
+        self,
+        feature: Incomplete | None = None,
+        location: Incomplete | None = None,
+        filename: Incomplete | None = None,
+    ) -> None: ...
+    def clear(self) -> None: ...
+    def add_location(self, location) -> None: ...
+    @staticmethod
+    def select_scenario_line_for(line, scenario_lines): ...
+    def discover_selected_scenarios(self, strict: bool = False): ...
+    def build_feature(self): ...
+
+class FeatureListParser:
+    @staticmethod
+    def parse(text, here: Incomplete | None = None): ...
+    @classmethod
+    def parse_file(cls, filename): ...
+
+class PathManager:
+    initial_paths: Incomplete
+    paths: Incomplete
+    def __init__(self, paths: Incomplete | None = None) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(self, *crap) -> None: ...
+    def add(self, path) -> None: ...
+
+def parse_features(feature_files, language: Incomplete | None = None): ...
+def collect_feature_locations(paths, strict: bool = True): ...
+def exec_file(
+    filename, globals_: Incomplete | None = None, locals_: Incomplete | None = None
+) -> None: ...
+def load_step_modules(step_paths) -> None: ...
+def make_undefined_step_snippet(step, language: Incomplete | None = None): ...
+def make_undefined_step_snippets(
+    undefined_steps, make_snippet: Incomplete | None = None
+): ...
+def print_undefined_step_snippets(
+    undefined_steps, stream: Incomplete | None = None, colored: bool = True
+) -> None: ...
+def reset_runtime() -> None: ...
diff --git a/features/stubs/behave/step_registry.pyi b/features/stubs/behave/step_registry.pyi
new file mode 100644
index 0000000..cc97873
--- /dev/null
+++ b/features/stubs/behave/step_registry.pyi
@@ -0,0 +1,34 @@
+import typing
+
+from _typeshed import Incomplete
+
+__all__ = ["given", "when", "then", "step", "Given", "When", "Then", "Step"]
+
+from typing import Callable, List
+
+class AmbiguousStep(ValueError): ...
+
+class StepRegistry:
+    steps: Incomplete
+    def __init__(self) -> None: ...
+    @staticmethod
+    def same_step_definition(step, other_pattern, other_location): ...
+    def add_step_definition(self, keyword, step_text, func) -> None: ...
+    def find_step_definition(self, step): ...
+    def find_match(self, step): ...
+    def make_decorator(self, step_type): ...
+
+# Names in __all__ with no definition:
+#   Given
+#   Step
+#   Then
+#   When
+#   given
+#   step
+#   then
+#   when
+def given(any: typing.Any) -> Callable[[typing.Any], List[str]]: ...
+def then(any: typing.Any) -> Callable[[typing.Any], List[str]]: ...
+def when(any: typing.Any) -> Callable[[typing.Any], List[str]]: ...
+
+registry = StepRegistry()
diff --git a/features/stubs/behave/tag_expression.pyi b/features/stubs/behave/tag_expression.pyi
new file mode 100644
index 0000000..2c8df62
--- /dev/null
+++ b/features/stubs/behave/tag_expression.pyi
@@ -0,0 +1,15 @@
+from collections.abc import Generator
+
+from _typeshed import Incomplete
+
+class TagExpression:
+    ands: Incomplete
+    limits: Incomplete
+    def __init__(self, tag_expressions) -> None: ...
+    @staticmethod
+    def normalize_tag(tag): ...
+    @classmethod
+    def normalized_tags_from_or(cls, expr) -> Generator[Incomplete, None, None]: ...
+    def store_and_extract_limits(self, tags) -> None: ...
+    def check(self, tags): ...
+    def __len__(self) -> int: ...
diff --git a/features/stubs/behave/tag_matcher.pyi b/features/stubs/behave/tag_matcher.pyi
new file mode 100644
index 0000000..ce205d3
--- /dev/null
+++ b/features/stubs/behave/tag_matcher.pyi
@@ -0,0 +1,92 @@
+from collections.abc import Generator
+
+from _typeshed import Incomplete
+
+class TagMatcher:
+    def should_run_with(self, tags): ...
+    def should_exclude_with(self, tags) -> None: ...
+
+class ActiveTagMatcher(TagMatcher):
+    value_separator: str
+    tag_prefixes: Incomplete
+    tag_schema: str
+    ignore_unknown_categories: bool
+    use_exclude_reason: bool
+    value_provider: Incomplete
+    tag_pattern: Incomplete
+    exclude_reason: Incomplete
+    def __init__(
+        self,
+        value_provider,
+        tag_prefixes: Incomplete | None = None,
+        value_separator: Incomplete | None = None,
+        ignore_unknown_categories: Incomplete | None = None,
+    ) -> None: ...
+    @classmethod
+    def make_tag_pattern(
+        cls, tag_prefixes, value_separator: Incomplete | None = None
+    ): ...
+    @classmethod
+    def make_category_tag(
+        cls,
+        category,
+        value: Incomplete | None = None,
+        tag_prefix: Incomplete | None = None,
+        value_sep: Incomplete | None = None,
+    ): ...
+    def is_tag_negated(self, tag): ...
+    def is_tag_group_enabled(self, group_category, group_tag_pairs): ...
+    def should_exclude_with(self, tags): ...
+    def select_active_tags(self, tags) -> Generator[Incomplete, None, None]: ...
+    def group_active_tags_by_category(
+        self, tags
+    ) -> Generator[Incomplete, None, None]: ...
+
+class PredicateTagMatcher(TagMatcher):
+    predicate: Incomplete
+    def __init__(self, exclude_function) -> None: ...
+    def should_exclude_with(self, tags): ...
+
+class CompositeTagMatcher(TagMatcher):
+    tag_matchers: Incomplete
+    def __init__(self, tag_matchers: Incomplete | None = None) -> None: ...
+    def should_exclude_with(self, tags): ...
+
+def setup_active_tag_values(active_tag_values, data) -> None: ...
+
+class OnlyWithCategoryTagMatcher(TagMatcher):
+    tag_prefix: str
+    value_separator: str
+    active_tag: Incomplete
+    category_tag_prefix: Incomplete
+    def __init__(
+        self,
+        category,
+        value,
+        tag_prefix: Incomplete | None = None,
+        value_sep: Incomplete | None = None,
+    ) -> None: ...
+    def should_exclude_with(self, tags): ...
+    def select_category_tags(self, tags): ...
+    @classmethod
+    def make_category_tag(
+        cls,
+        category,
+        value: Incomplete | None = None,
+        tag_prefix: Incomplete | None = None,
+        value_sep: Incomplete | None = None,
+    ): ...
+
+class OnlyWithAnyCategoryTagMatcher(TagMatcher):
+    value_provider: Incomplete
+    tag_prefix: Incomplete
+    value_separator: Incomplete
+    def __init__(
+        self,
+        value_provider,
+        tag_prefix: Incomplete | None = None,
+        value_sep: Incomplete | None = None,
+    ) -> None: ...
+    def should_exclude_with(self, tags): ...
+    def select_category_tags(self, tags): ...
+    def parse_category_tag(self, tag): ...
diff --git a/features/stubs/behave/textutil.pyi b/features/stubs/behave/textutil.pyi
new file mode 100644
index 0000000..b42de89
--- /dev/null
+++ b/features/stubs/behave/textutil.pyi
@@ -0,0 +1,16 @@
+from _typeshed import Incomplete
+
+BEHAVE_UNICODE_ERRORS: Incomplete
+
+def make_indentation(indent_size, part: str = " "): ...
+def indent(text, prefix): ...
+def compute_words_maxsize(words): ...
+def is_ascii_encoding(encoding): ...
+def select_best_encoding(outstream: Incomplete | None = None): ...
+def text(
+    value, encoding: Incomplete | None = None, errors: Incomplete | None = None
+): ...
+def to_texts(
+    args, encoding: Incomplete | None = None, errors: Incomplete | None = None
+): ...
+def ensure_stream_with_encoder(stream, encoding: Incomplete | None = None): ...
diff --git a/features/stubs/behave/userdata.pyi b/features/stubs/behave/userdata.pyi
new file mode 100644
index 0000000..9e14ab9
--- /dev/null
+++ b/features/stubs/behave/userdata.pyi
@@ -0,0 +1,48 @@
+from collections.abc import Generator
+
+from _typeshed import Incomplete
+from behave._types import Unknown as Unknown
+
+def parse_bool(text): ...
+def parse_user_define(text): ...
+def unqote(text): ...
+
+class UserData(dict):
+    def getas(
+        self,
+        convert,
+        name,
+        default: Incomplete | None = None,
+        valuetype: Incomplete | None = None,
+    ): ...
+    def getint(self, name, default: int = 0): ...
+    def getfloat(self, name, default: float = 0.0): ...
+    def getbool(self, name, default: bool = False): ...
+    @classmethod
+    def make(cls, data): ...
+
+class UserDataNamespace:
+    namespace: Incomplete
+    data: Incomplete
+    def __init__(self, namespace, data: Incomplete | None = None) -> None: ...
+    @staticmethod
+    def make_scoped(namespace, name): ...
+    def get(self, name, default: Incomplete | None = None): ...
+    def getas(
+        self,
+        convert,
+        name,
+        default: Incomplete | None = None,
+        valuetype: Incomplete | None = None,
+    ): ...
+    def getint(self, name, default: int = 0): ...
+    def getfloat(self, name, default: float = 0.0): ...
+    def getbool(self, name, default: bool = False): ...
+    def __contains__(self, name) -> bool: ...
+    def __getitem__(self, name): ...
+    def __setitem__(self, name, value) -> None: ...
+    def __len__(self) -> int: ...
+    def scoped_keys(self): ...
+    def keys(self) -> Generator[Incomplete, None, None]: ...
+    def values(self) -> Generator[Incomplete, None, None]: ...
+    def items(self) -> Generator[Incomplete, None, None]: ...
diff --git a/poetry.lock b/poetry.lock
index 402c7e4..ec03412 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -189,6 +189,26 @@ files = [
 pyflakes = ">=3.0.0"
 tomli = {version = ">=2.0.1", markers = "python_version < \"3.11\""}
 
+[[package]]
+name = "behave"
+version = "1.2.6"
+description = "behave is behaviour-driven development, Python style"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
+files = [
+    {file = "behave-1.2.6-py2.py3-none-any.whl", hash = "sha256:ebda1a6c9e5bfe95c5f9f0a2794e01c7098b3dde86c10a95d8621c5907ff6f1c"},
+    {file = "behave-1.2.6.tar.gz", hash = "sha256:b9662327aa53294c1351b0a9c369093ccec1d21026f050c3bd9b3e5cccf81a86"},
+]
+
+[package.dependencies]
+parse = ">=1.8.2"
+parse-type = ">=0.4.2"
+six = ">=1.11"
+
+[package.extras]
+develop = ["coverage", "invoke (>=0.21.0)", "modernize (>=0.5)", "path.py (>=8.1.2)", "pathlib", "pycmd", "pylint", "pytest (>=3.0)", "pytest-cov", "tox"]
+docs = ["sphinx (>=1.6)", "sphinx-bootstrap-theme (>=0.6)"]
+
 [[package]]
 name = "black"
 version = "24.4.0"
@@ -892,6 +912,37 @@ files = [
     {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"},
 ]
 
+[[package]]
+name = "parse"
+version = "1.20.2"
+description = "parse() is the opposite of format()"
+optional = false
+python-versions = "*"
+files = [
+    {file = "parse-1.20.2-py2.py3-none-any.whl", hash = "sha256:967095588cb802add9177d0c0b6133b5ba33b1ea9007ca800e526f42a85af558"},
+    {file = "parse-1.20.2.tar.gz", hash = "sha256:b41d604d16503c79d81af5165155c0b20f6c8d6c559efa66b4b695c3e5a0a0ce"},
+]
+
+[[package]]
+name = "parse-type"
+version = "0.6.2"
+description = "Simplifies to build parse types based on the parse module"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*"
+files = [
+    {file = "parse_type-0.6.2-py2.py3-none-any.whl", hash = "sha256:06d39a8b70fde873eb2a131141a0e79bb34a432941fb3d66fad247abafc9766c"},
+    {file = "parse_type-0.6.2.tar.gz", hash = "sha256:79b1f2497060d0928bc46016793f1fca1057c4aacdf15ef876aa48d75a73a355"},
+]
+
+[package.dependencies]
+parse = {version = ">=1.18.0", markers = "python_version >= \"3.0\""}
+six = ">=1.15"
+
+[package.extras]
+develop = ["build (>=0.5.1)", "coverage (>=4.4)", "pylint", "pytest (<5.0)", "pytest (>=5.0)", "pytest-cov", "pytest-html (>=1.19.0)", "ruff", "tox (>=2.8,<4.0)", "twine (>=1.13.0)", "virtualenv (<20.22.0)", "virtualenv (>=20.0.0)"]
+docs = ["Sphinx (>=1.6)", "sphinx-bootstrap-theme (>=0.6.0)"]
+testing = ["pytest (<5.0)", "pytest (>=5.0)", "pytest-html (>=1.19.0)"]
+
 [[package]]
 name = "pathspec"
 version = "0.12.1"
@@ -1050,6 +1101,17 @@ files = [
     {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
 ]
 
+[[package]]
+name = "types-six"
+version = "1.16.21.20240513"
+description = "Typing stubs for six"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "types-six-1.16.21.20240513.tar.gz", hash = "sha256:cdf445b5161bf17753500713a475ab79a45bd0d87728b8bfcecd86e2fbf66402"},
+    {file = "types_six-1.16.21.20240513-py3-none-any.whl", hash = "sha256:af2a105be6d504339bfed81319cc8e8697865f0ee5c6baa63658f127b33b9e63"},
+]
+
 [[package]]
 name = "typing-extensions"
 version = "4.11.0"
@@ -1265,4 +1327,4 @@ multidict = ">=4.0"
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.8.1"
-content-hash = "4fcd8abfd5887a6e94438c508bae48e3dcb5981d5455dbc02dfc52564ef9e09f"
+content-hash = "4f5c735b518a8d103d247d33bf985cf65c576a3f513b4ebf2393fcfbcf9eedb7"
diff --git a/pyproject.toml b/pyproject.toml
index f22f292..fae300c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -20,6 +20,8 @@ PyNaCl = "^1.5.0"
 python = ">=3.8.1"
 tomli = "^2.0.1"
 typing-extensions = "^4.4.0"
+behave = "^1.2.6"
+types-six = "^1.16.21.20240513"
 
 [tool.poetry.dev-dependencies]
 autoflake = "2.2.0"