🥮 mooncakes.io

    moonrockz/moonspec/core does not have a README file

    Attachable

    source
    pub trait Attachable {
      attach(Self, String, String, file_name? : String) -> Unit
      attach_bytes(Self, Bytes, String, file_name? : String) -> Unit
      attach_url(Self, String, String) -> Unit
      pending_attachments(Self) -> Array[PendingAttachment]
    }

    Trait for any context that can buffer attachments.

    FromStepArg

    source
    pub(open) trait FromStepArg {
      from_step_arg(StepArg) -> Self raise
    }

    Trait for extracting typed values from step arguments. Implementations convert a StepArg into the target type, raising an Error if the StepValue variant doesn't match.

    MessageSink

    source
    pub(open) trait MessageSink {
      on_message(Self, 
    Envelope    ) -> Unit
      output(Self) -> String
    }

    A sink that receives cucumber-messages Envelope events during a test run.

    StepLibrary

    source
    pub(open) trait StepLibrary {
      steps(Self) -> ArrayView[StepDef]
    }

    A composable group of step definitions.

    Implement this on structs that provide reusable step definitions. Libraries return an immutable view of their steps via ArrayView.

    World

    source
    pub(open) trait World {
      configure(Self, Setup) -> Unit
    }

    Step registration trait. Users implement this on their world struct.

    Called once per scenario with a fresh Default-constructed instance. Closures registered via Setup capture self, sharing world state between steps within the same scenario. Since MoonBit structs are reference types, mutations through closures are visible to all step handlers.

    Example:
    struct MyWorld { mut count : Int } derive(Default)

impl @moonspec.World for MyWorld with configure(self, s) {
  s.given("a count of {int}", fn(ctx) {
    match ctx[0] { { value: IntVal(n), .. } => self.count = n; _ => () }
  })
}

    MoonspecError

    source
    pub suberror MoonspecError {
      UndefinedStep(String, String, String, Array[String])
      PendingStep(String, String, String)
      StepFailed(String, String, String)
      ScenarioFailed(String, String, Array[MoonspecError])
      RunFailed(String, Array[MoonspecError])
    }

    Structured error hierarchy for moonspec.

    Step-level errors aggregate into ScenarioFailed, which aggregates into RunFailed. This enables rich diagnostics and the run_or_fail! API.

    CaseHookCtx

    source
    pub(all) struct CaseHookCtx {
      // private fields
    }

    Hook context for test case-level hooks (before/after_test_case).

    CaseHookCtx::attach

    source
    fn CaseHookCtx::attach(self : CaseHookCtx, body : String, media_type : String, file_name? : String) -> Unit

    CaseHookCtx::attach_bytes

    source
    fn CaseHookCtx::attach_bytes(self : CaseHookCtx, data : Bytes, media_type : String, file_name? : String) -> Unit

    CaseHookCtx::attach_url

    source
    fn CaseHookCtx::attach_url(self : CaseHookCtx, url : String, media_type : String) -> Unit

    CaseHookCtx::new

    source
    fn CaseHookCtx::new(scenario : ScenarioInfo) -> CaseHookCtx

    CaseHookCtx::pending_attachments

    source
    fn CaseHookCtx::pending_attachments(self : CaseHookCtx) -> Array[PendingAttachment]

    CaseHookCtx::scenario

    source
    fn CaseHookCtx::scenario(self : CaseHookCtx) -> ScenarioInfo

    Cells

    source
    pub struct Cells {
      // private fields

      fn new(data : Array[String]) -> Cells
    }

    Immutable wrapper around an array of cell values in a DataTable row.
    impl Eq for Cells
    impl Show for Cells

    Cells::get

    source
    fn Cells::get(self : Cells, index : Int) -> String

    Cells::length

    source
    fn Cells::length(self : Cells) -> Int

    Cells::values

    source
    fn Cells::values(self : Cells) -> ArrayView[String]

    Column

    source
    pub(all) struct Column {
      name : String
      index : Int

      fn new(name~ : String, index~ : Int) -> Column
    }

    A named column in a DataTable, derived from the header row.
    impl Eq for Column
    impl Show for Column

    Columns

    source
    pub struct Columns {
      // private fields

      fn new(data : Array[Column]) -> Columns
    }

    Immutable wrapper around an array of columns in a DataTable.
    impl Eq for Columns
    impl Show for Columns

    Columns::find

    source
    fn Columns::find(self : Columns, name : String) -> Column?

    Columns::get

    source
    fn Columns::get(self : Columns, index : Int) -> Column

    Columns::length

    source
    fn Columns::length(self : Columns) -> Int

    Columns::values

    source
    fn Columns::values(self : Columns) -> ArrayView[Column]

    CompiledStep

    source
    type CompiledStep

    Internal: a compiled step entry pairing a StepDef with its parsed expression.

    Ctx

    source
    pub(all) struct Ctx {
      // private fields
    }

    Step execution context. Wraps matched arguments with scenario/step metadata and an attachment buffer.

    Ctx::arg

    source
    fn Ctx::arg(self : Ctx, index : Int) -> StepArg

    Explicit index access to a step argument.

    Ctx::args

    source
    fn Ctx::args(self : Ctx) -> ArrayView[StepArg]

    View of all step arguments.

    Ctx::attach

    source
    fn Ctx::attach(self : Ctx, body : String, media_type : String, file_name? : String) -> Unit

    Attach text content to the current step/hook.

    Ctx::attach_bytes

    source
    fn Ctx::attach_bytes(self : Ctx, data : Bytes, media_type : String, file_name? : String) -> Unit

    Attach binary content (Base64 encoded) to the current step/hook.

    Ctx::attach_url

    source
    fn Ctx::attach_url(self : Ctx, url : String, media_type : String) -> Unit

    Attach an external URL reference to the current step/hook.

    Ctx::new

    source
    fn Ctx::new(args : Array[StepArg], scenario : ScenarioInfo, step : StepInfo) -> Ctx

    Create a new Ctx.

    Ctx::op_get

    source
    fn Ctx::op_get(self : Ctx, index : Int) -> StepArg

    Index access to step arguments.

    Ctx::pending_attachments

    source
    fn Ctx::pending_attachments(self : Ctx) -> Array[PendingAttachment]

    Access buffered attachments (for executor draining).

    Ctx::scenario

    source
    fn Ctx::scenario(self : Ctx) -> ScenarioInfo

    Scenario metadata (feature name, scenario name, tags).

    Ctx::step

    source
    fn Ctx::step(self : Ctx) -> StepInfo

    Step metadata (keyword, text).

    Ctx::value

    source
    fn Ctx::value(self : Ctx, index : Int) -> StepValue

    Convenience accessor: returns the StepValue at the given argument index.

    CustomParamTypeInfo

    source
    pub(all) struct CustomParamTypeInfo {
      name : String
      patterns : Array[String]
    }

    Info about a custom parameter type, for envelope emission.

    DataTable

    source
    pub(all) struct DataTable {
      rows : Rows
      columns : Columns

      fn new(raw_rows : Array[Array[String]]) -> DataTable
    }

    A DataTable from a Gherkin step. First row is treated as column headers.
    impl Eq for DataTable
    impl Show for DataTable

    DataTable::as_maps

    source
    fn DataTable::as_maps(self : DataTable) -> Array[Map[String, String]]

    DataTable::col_count

    source
    fn DataTable::col_count(self : DataTable) -> Int

    DataTable::from_rows

    source
    fn DataTable::from_rows(raw_rows : Array[Array[String]]) -> DataTable

    Construct a DataTable from raw row data (public factory).

    DataTable::row_count

    source
    fn DataTable::row_count(self : DataTable) -> Int

    DocString

    source
    pub(all) struct DocString {
      content : String
      media_type : String?

      fn new(content~ : String, media_type? : String) -> DocString
    }

    A DocString from a Gherkin step — multi-line text with optional media type.
    impl Eq for DocString
    impl Show for DocString

    HookError

    source
    pub(all) enum HookError {
      StepFailed(String, StepKeyword, String)
      ScenarioFailed(String, String, String)
    }

    Structured error reported to after-hooks.
    impl Eq for HookError
    impl Show for HookError

    HookHandler

    source
    pub(all) enum HookHandler {
      RunHandler((RunHookCtx) -> Unit raise)
      RunAfterHandler((RunHookCtx, HookResult) -> Unit raise)
      CaseHandler((CaseHookCtx) -> Unit raise)
      CaseAfterHandler((CaseHookCtx, HookResult) -> Unit raise)
      StepHandler((StepHookCtx) -> Unit raise)
      StepAfterHandler((StepHookCtx, HookResult) -> Unit raise)
    }

    Typed handler for different hook scopes.

    HookRegistry

    source
    pub(all) struct HookRegistry {
      // private fields
    }

    Registry of lifecycle hooks with auto-incrementing IDs.

    HookRegistry::add

    source
    fn HookRegistry::add(self : HookRegistry, type_ : HookType, handler : HookHandler, source? : StepSource?) -> Unit

    Register a hook with the given type, handler, and optional source location.

    HookRegistry::by_type

    source
    fn HookRegistry::by_type(self : HookRegistry, type_ : HookType) -> Array[RegisteredHook]

    Return all registered hooks matching the given type.

    HookRegistry::hooks

    source

    Return all registered hooks as a read-only ArrayView.

    HookRegistry::new

    source

    Create an empty hook registry.

    HookResult

    source
    pub(all) enum HookResult {
      Passed
      Failed(Array[HookError])
    }

    Result passed to after-hooks indicating pass/fail with structured errors.
    impl Eq for HookResult
    impl Show for HookResult

    HookType

    source
    pub(all) enum HookType {
      BeforeTestRun
      AfterTestRun
      BeforeTestCase
      AfterTestCase
      BeforeTestStep
      AfterTestStep
    }

    The six Cucumber lifecycle hook types.
    impl Eq for HookType
    impl Show for HookType

    PendingAttachment

    source
    pub(all) enum PendingAttachment {
      Embedded(String, 
    AttachmentContentEncoding    , String, String?)
      External(String, String)
    }

    A buffered attachment waiting to be emitted as an envelope.

    RegisteredHook

    source
    pub(all) struct RegisteredHook {
      id : String
      type_ : HookType
      handler : HookHandler
      source : StepSource?
    }

    A registered hook entry with id, type, handler, and source location.

    Row

    source
    pub(all) struct Row {
      cells : Cells

      fn new(cells : Array[String]) -> Row
    }

    A single row in a DataTable, wrapping its cell values in an immutable Cells.
    impl Eq for Row
    impl Show for Row

    Rows

    source
    pub struct Rows {
      // private fields

      fn new(data : Array[Row]) -> Rows
    }

    Immutable wrapper around an array of rows in a DataTable.
    impl Eq for Rows
    impl Show for Rows

    Rows::get

    source
    fn Rows::get(self : Rows, index : Int) -> Row

    Rows::length

    source
    fn Rows::length(self : Rows) -> Int

    Rows::values

    source
    fn Rows::values(self : Rows) -> ArrayView[Row]

    RunHookCtx

    source
    pub(all) struct RunHookCtx {
      // private fields
    }

    Hook context for test run-level hooks (before/after_test_run).

    RunHookCtx::attach

    source
    fn RunHookCtx::attach(self : RunHookCtx, body : String, media_type : String, file_name? : String) -> Unit

    RunHookCtx::attach_bytes

    source
    fn RunHookCtx::attach_bytes(self : RunHookCtx, data : Bytes, media_type : String, file_name? : String) -> Unit

    RunHookCtx::attach_url

    source
    fn RunHookCtx::attach_url(self : RunHookCtx, url : String, media_type : String) -> Unit

    RunHookCtx::new

    source
    fn RunHookCtx::new() -> RunHookCtx

    RunHookCtx::pending_attachments

    source
    fn RunHookCtx::pending_attachments(self : RunHookCtx) -> Array[PendingAttachment]

    ScenarioInfo

    source
    pub(all) struct ScenarioInfo {
      feature_name : String
      scenario_name : String
      tags : Array[String]
    }

    Information about a scenario being executed.
    impl Eq for ScenarioInfo

    Setup

    source
    pub(all) struct Setup {
      // private fields
    }

    User-facing configuration facade for registering steps and parameter types. Wraps StepRegistry and ParamTypeRegistry as siblings.

    Setup::add_param_type

    source

    Register a custom parameter type with name and regex patterns. An optional transformer converts matched text into a typed ParamValue.

    Setup::add_param_type_strings

    source
    fn Setup::add_param_type_strings(self : Setup, name : String, patterns : Array[String], transformer? : 
    Transformer    ) -> Unit

    Register a custom parameter type with name and string regex patterns. Convenience method that avoids requiring callers to import cucumber-expressions. An optional transformer converts matched text into a typed ParamValue.

    Setup::after_test_case

    source
    #callsite(autofill(loc))
    fn Setup::after_test_case(self : Setup, handler : (CaseHookCtx, HookResult) -> Unit raise, loc~ : SourceLoc) -> Unit

    Register a hook to run after each test case (scenario).

    Setup::after_test_run

    source
    #callsite(autofill(loc))
    fn Setup::after_test_run(self : Setup, handler : (RunHookCtx, HookResult) -> Unit raise, loc~ : SourceLoc) -> Unit

    Register a hook to run after the entire test run.

    Setup::after_test_step

    source
    #callsite(autofill(loc))
    fn Setup::after_test_step(self : Setup, handler : (StepHookCtx, HookResult) -> Unit raise, loc~ : SourceLoc) -> Unit

    Register a hook to run after each test step.

    Setup::before_test_case

    source
    #callsite(autofill(loc))
    fn Setup::before_test_case(self : Setup, handler : (CaseHookCtx) -> Unit raise, loc~ : SourceLoc) -> Unit

    Register a hook to run before each test case (scenario).

    Setup::before_test_run

    source
    #callsite(autofill(loc))
    fn Setup::before_test_run(self : Setup, handler : (RunHookCtx) -> Unit raise, loc~ : SourceLoc) -> Unit

    Register a hook to run before the entire test run.

    Setup::before_test_step

    source
    #callsite(autofill(loc))
    fn Setup::before_test_step(self : Setup, handler : (StepHookCtx) -> Unit raise, loc~ : SourceLoc) -> Unit

    Register a hook to run before each test step.

    Setup::custom_param_types

    source
    fn Setup::custom_param_types(self : Setup) -> Array[CustomParamTypeInfo]

    Return custom (non-built-in) parameter types for envelope emission. Built-in types (int, float, string, word, anonymous "") are excluded.

    Setup::given

    source
    fn Setup::given(self : Setup, pattern : String, handler : (Ctx) -> Unit raise) -> Unit

    Register a Given step.

    Setup::given0

    source
    fn Setup::given0(self : Setup, pattern : String, handler : () -> Unit raise) -> Unit

    Setup::given0_ctx

    source
    fn Setup::given0_ctx(self : Setup, pattern : String, handler : (Ctx) -> Unit raise) -> Unit

    Setup::given1

    source
    fn[A : FromStepArg] Setup::given1(self : Setup, pattern : String, handler : (A) -> Unit raise) -> Unit

    Setup::given10

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] Setup::given10(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J) -> Unit raise) -> Unit

    Setup::given10_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] Setup::given10_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, Ctx) -> Unit raise) -> Unit

    Setup::given11

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] Setup::given11(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K) -> Unit raise) -> Unit

    Setup::given11_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] Setup::given11_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, Ctx) -> Unit raise) -> Unit

    Setup::given12

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] Setup::given12(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L) -> Unit raise) -> Unit

    Setup::given12_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] Setup::given12_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, Ctx) -> Unit raise) -> Unit

    Setup::given13

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] Setup::given13(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M) -> Unit raise) -> Unit

    Setup::given13_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] Setup::given13_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, Ctx) -> Unit raise) -> Unit

    Setup::given14

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] Setup::given14(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Unit raise) -> Unit

    Setup::given14_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] Setup::given14_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, Ctx) -> Unit raise) -> Unit

    Setup::given15

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] Setup::given15(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Unit raise) -> Unit

    Setup::given15_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] Setup::given15_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Ctx) -> Unit raise) -> Unit

    Setup::given16

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] Setup::given16(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Unit raise) -> Unit

    Setup::given16_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] Setup::given16_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Ctx) -> Unit raise) -> Unit

    Setup::given17

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] Setup::given17(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) -> Unit raise) -> Unit

    Setup::given17_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] Setup::given17_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Ctx) -> Unit raise) -> Unit

    Setup::given18

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] Setup::given18(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) -> Unit raise) -> Unit

    Setup::given18_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] Setup::given18_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Ctx) -> Unit raise) -> Unit

    Setup::given19

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] Setup::given19(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> Unit raise) -> Unit

    Setup::given19_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] Setup::given19_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Ctx) -> Unit raise) -> Unit

    Setup::given1_ctx

    source
    fn[A : FromStepArg] Setup::given1_ctx(self : Setup, pattern : String, handler : (A, Ctx) -> Unit raise) -> Unit

    Setup::given2

    source
    fn[A : FromStepArg, B : FromStepArg] Setup::given2(self : Setup, pattern : String, handler : (A, B) -> Unit raise) -> Unit

    Setup::given20

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] Setup::given20(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) -> Unit raise) -> Unit

    Setup::given20_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] Setup::given20_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Ctx) -> Unit raise) -> Unit

    Setup::given21

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] Setup::given21(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) -> Unit raise) -> Unit

    Setup::given21_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] Setup::given21_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Ctx) -> Unit raise) -> Unit

    Setup::given22

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] Setup::given22(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) -> Unit raise) -> Unit

    Setup::given22_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] Setup::given22_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Ctx) -> Unit raise) -> Unit

    Setup::given2_ctx

    source
    fn[A : FromStepArg, B : FromStepArg] Setup::given2_ctx(self : Setup, pattern : String, handler : (A, B, Ctx) -> Unit raise) -> Unit

    Setup::given3

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] Setup::given3(self : Setup, pattern : String, handler : (A, B, C) -> Unit raise) -> Unit

    Setup::given3_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] Setup::given3_ctx(self : Setup, pattern : String, handler : (A, B, C, Ctx) -> Unit raise) -> Unit

    Setup::given4

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] Setup::given4(self : Setup, pattern : String, handler : (A, B, C, D) -> Unit raise) -> Unit

    Setup::given4_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] Setup::given4_ctx(self : Setup, pattern : String, handler : (A, B, C, D, Ctx) -> Unit raise) -> Unit

    Setup::given5

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] Setup::given5(self : Setup, pattern : String, handler : (A, B, C, D, E) -> Unit raise) -> Unit

    Setup::given5_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] Setup::given5_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, Ctx) -> Unit raise) -> Unit

    Setup::given6

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] Setup::given6(self : Setup, pattern : String, handler : (A, B, C, D, E, F) -> Unit raise) -> Unit

    Setup::given6_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] Setup::given6_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, Ctx) -> Unit raise) -> Unit

    Setup::given7

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] Setup::given7(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G) -> Unit raise) -> Unit

    Setup::given7_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] Setup::given7_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, Ctx) -> Unit raise) -> Unit

    Setup::given8

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] Setup::given8(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H) -> Unit raise) -> Unit

    Setup::given8_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] Setup::given8_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, Ctx) -> Unit raise) -> Unit

    Setup::given9

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] Setup::given9(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I) -> Unit raise) -> Unit

    Setup::given9_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] Setup::given9_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, Ctx) -> Unit raise) -> Unit

    Setup::hook_registry

    source
    fn Setup::hook_registry(self : Setup) -> HookRegistry

    Access the underlying hook registry (for runner internals).

    Setup::new

    source
    fn Setup::new() -> Setup

    Setup::param_registry

    source

    Access the underlying param type registry (for runner internals).

    Setup::step

    source
    fn Setup::step(self : Setup, pattern : String, handler : (Ctx) -> Unit raise) -> Unit

    Register a step that matches any keyword.

    Setup::step0

    source
    fn Setup::step0(self : Setup, pattern : String, handler : () -> Unit raise) -> Unit

    Setup::step0_ctx

    source
    fn Setup::step0_ctx(self : Setup, pattern : String, handler : (Ctx) -> Unit raise) -> Unit

    Setup::step1

    source
    fn[A : FromStepArg] Setup::step1(self : Setup, pattern : String, handler : (A) -> Unit raise) -> Unit

    Setup::step10

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] Setup::step10(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J) -> Unit raise) -> Unit

    Setup::step10_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] Setup::step10_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, Ctx) -> Unit raise) -> Unit

    Setup::step11

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] Setup::step11(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K) -> Unit raise) -> Unit

    Setup::step11_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] Setup::step11_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, Ctx) -> Unit raise) -> Unit

    Setup::step12

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] Setup::step12(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L) -> Unit raise) -> Unit

    Setup::step12_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] Setup::step12_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, Ctx) -> Unit raise) -> Unit

    Setup::step13

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] Setup::step13(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M) -> Unit raise) -> Unit

    Setup::step13_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] Setup::step13_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, Ctx) -> Unit raise) -> Unit

    Setup::step14

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] Setup::step14(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Unit raise) -> Unit

    Setup::step14_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] Setup::step14_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, Ctx) -> Unit raise) -> Unit

    Setup::step15

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] Setup::step15(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Unit raise) -> Unit

    Setup::step15_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] Setup::step15_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Ctx) -> Unit raise) -> Unit

    Setup::step16

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] Setup::step16(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Unit raise) -> Unit

    Setup::step16_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] Setup::step16_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Ctx) -> Unit raise) -> Unit

    Setup::step17

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] Setup::step17(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) -> Unit raise) -> Unit

    Setup::step17_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] Setup::step17_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Ctx) -> Unit raise) -> Unit

    Setup::step18

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] Setup::step18(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) -> Unit raise) -> Unit

    Setup::step18_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] Setup::step18_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Ctx) -> Unit raise) -> Unit

    Setup::step19

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] Setup::step19(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> Unit raise) -> Unit

    Setup::step19_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] Setup::step19_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Ctx) -> Unit raise) -> Unit

    Setup::step1_ctx

    source
    fn[A : FromStepArg] Setup::step1_ctx(self : Setup, pattern : String, handler : (A, Ctx) -> Unit raise) -> Unit

    Setup::step2

    source
    fn[A : FromStepArg, B : FromStepArg] Setup::step2(self : Setup, pattern : String, handler : (A, B) -> Unit raise) -> Unit

    Setup::step20

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] Setup::step20(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) -> Unit raise) -> Unit

    Setup::step20_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] Setup::step20_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Ctx) -> Unit raise) -> Unit

    Setup::step21

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] Setup::step21(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) -> Unit raise) -> Unit

    Setup::step21_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] Setup::step21_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Ctx) -> Unit raise) -> Unit

    Setup::step22

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] Setup::step22(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) -> Unit raise) -> Unit

    Setup::step22_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] Setup::step22_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Ctx) -> Unit raise) -> Unit

    Setup::step2_ctx

    source
    fn[A : FromStepArg, B : FromStepArg] Setup::step2_ctx(self : Setup, pattern : String, handler : (A, B, Ctx) -> Unit raise) -> Unit

    Setup::step3

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] Setup::step3(self : Setup, pattern : String, handler : (A, B, C) -> Unit raise) -> Unit

    Setup::step3_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] Setup::step3_ctx(self : Setup, pattern : String, handler : (A, B, C, Ctx) -> Unit raise) -> Unit

    Setup::step4

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] Setup::step4(self : Setup, pattern : String, handler : (A, B, C, D) -> Unit raise) -> Unit

    Setup::step4_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] Setup::step4_ctx(self : Setup, pattern : String, handler : (A, B, C, D, Ctx) -> Unit raise) -> Unit

    Setup::step5

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] Setup::step5(self : Setup, pattern : String, handler : (A, B, C, D, E) -> Unit raise) -> Unit

    Setup::step5_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] Setup::step5_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, Ctx) -> Unit raise) -> Unit

    Setup::step6

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] Setup::step6(self : Setup, pattern : String, handler : (A, B, C, D, E, F) -> Unit raise) -> Unit

    Setup::step6_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] Setup::step6_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, Ctx) -> Unit raise) -> Unit

    Setup::step7

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] Setup::step7(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G) -> Unit raise) -> Unit

    Setup::step7_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] Setup::step7_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, Ctx) -> Unit raise) -> Unit

    Setup::step8

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] Setup::step8(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H) -> Unit raise) -> Unit

    Setup::step8_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] Setup::step8_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, Ctx) -> Unit raise) -> Unit

    Setup::step9

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] Setup::step9(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I) -> Unit raise) -> Unit

    Setup::step9_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] Setup::step9_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, Ctx) -> Unit raise) -> Unit

    Setup::step_registry

    source
    fn Setup::step_registry(self : Setup) -> StepRegistry

    Access the underlying step registry (for runner internals).

    Setup::then

    source
    fn Setup::then(self : Setup, pattern : String, handler : (Ctx) -> Unit raise) -> Unit

    Register a Then step.

    Setup::then0

    source
    fn Setup::then0(self : Setup, pattern : String, handler : () -> Unit raise) -> Unit

    Setup::then0_ctx

    source
    fn Setup::then0_ctx(self : Setup, pattern : String, handler : (Ctx) -> Unit raise) -> Unit

    Setup::then1

    source
    fn[A : FromStepArg] Setup::then1(self : Setup, pattern : String, handler : (A) -> Unit raise) -> Unit

    Setup::then10

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] Setup::then10(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J) -> Unit raise) -> Unit

    Setup::then10_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] Setup::then10_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, Ctx) -> Unit raise) -> Unit

    Setup::then11

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] Setup::then11(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K) -> Unit raise) -> Unit

    Setup::then11_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] Setup::then11_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, Ctx) -> Unit raise) -> Unit

    Setup::then12

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] Setup::then12(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L) -> Unit raise) -> Unit

    Setup::then12_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] Setup::then12_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, Ctx) -> Unit raise) -> Unit

    Setup::then13

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] Setup::then13(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M) -> Unit raise) -> Unit

    Setup::then13_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] Setup::then13_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, Ctx) -> Unit raise) -> Unit

    Setup::then14

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] Setup::then14(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Unit raise) -> Unit

    Setup::then14_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] Setup::then14_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, Ctx) -> Unit raise) -> Unit

    Setup::then15

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] Setup::then15(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Unit raise) -> Unit

    Setup::then15_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] Setup::then15_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Ctx) -> Unit raise) -> Unit

    Setup::then16

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] Setup::then16(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Unit raise) -> Unit

    Setup::then16_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] Setup::then16_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Ctx) -> Unit raise) -> Unit

    Setup::then17

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] Setup::then17(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) -> Unit raise) -> Unit

    Setup::then17_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] Setup::then17_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Ctx) -> Unit raise) -> Unit

    Setup::then18

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] Setup::then18(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) -> Unit raise) -> Unit

    Setup::then18_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] Setup::then18_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Ctx) -> Unit raise) -> Unit

    Setup::then19

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] Setup::then19(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> Unit raise) -> Unit

    Setup::then19_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] Setup::then19_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Ctx) -> Unit raise) -> Unit

    Setup::then1_ctx

    source
    fn[A : FromStepArg] Setup::then1_ctx(self : Setup, pattern : String, handler : (A, Ctx) -> Unit raise) -> Unit

    Setup::then2

    source
    fn[A : FromStepArg, B : FromStepArg] Setup::then2(self : Setup, pattern : String, handler : (A, B) -> Unit raise) -> Unit

    Setup::then20

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] Setup::then20(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) -> Unit raise) -> Unit

    Setup::then20_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] Setup::then20_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Ctx) -> Unit raise) -> Unit

    Setup::then21

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] Setup::then21(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) -> Unit raise) -> Unit

    Setup::then21_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] Setup::then21_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Ctx) -> Unit raise) -> Unit

    Setup::then22

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] Setup::then22(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) -> Unit raise) -> Unit

    Setup::then22_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] Setup::then22_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Ctx) -> Unit raise) -> Unit

    Setup::then2_ctx

    source
    fn[A : FromStepArg, B : FromStepArg] Setup::then2_ctx(self : Setup, pattern : String, handler : (A, B, Ctx) -> Unit raise) -> Unit

    Setup::then3

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] Setup::then3(self : Setup, pattern : String, handler : (A, B, C) -> Unit raise) -> Unit

    Setup::then3_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] Setup::then3_ctx(self : Setup, pattern : String, handler : (A, B, C, Ctx) -> Unit raise) -> Unit

    Setup::then4

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] Setup::then4(self : Setup, pattern : String, handler : (A, B, C, D) -> Unit raise) -> Unit

    Setup::then4_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] Setup::then4_ctx(self : Setup, pattern : String, handler : (A, B, C, D, Ctx) -> Unit raise) -> Unit

    Setup::then5

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] Setup::then5(self : Setup, pattern : String, handler : (A, B, C, D, E) -> Unit raise) -> Unit

    Setup::then5_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] Setup::then5_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, Ctx) -> Unit raise) -> Unit

    Setup::then6

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] Setup::then6(self : Setup, pattern : String, handler : (A, B, C, D, E, F) -> Unit raise) -> Unit

    Setup::then6_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] Setup::then6_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, Ctx) -> Unit raise) -> Unit

    Setup::then7

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] Setup::then7(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G) -> Unit raise) -> Unit

    Setup::then7_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] Setup::then7_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, Ctx) -> Unit raise) -> Unit

    Setup::then8

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] Setup::then8(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H) -> Unit raise) -> Unit

    Setup::then8_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] Setup::then8_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, Ctx) -> Unit raise) -> Unit

    Setup::then9

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] Setup::then9(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I) -> Unit raise) -> Unit

    Setup::then9_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] Setup::then9_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, Ctx) -> Unit raise) -> Unit

    Setup::use_library

    source
    fn[L : StepLibrary] Setup::use_library(self : Setup, library : L) -> Unit

    Compose a StepLibrary into this setup's registry.

    Setup::when

    source
    fn Setup::when(self : Setup, pattern : String, handler : (Ctx) -> Unit raise) -> Unit

    Register a When step.

    Setup::when0

    source
    fn Setup::when0(self : Setup, pattern : String, handler : () -> Unit raise) -> Unit

    Setup::when0_ctx

    source
    fn Setup::when0_ctx(self : Setup, pattern : String, handler : (Ctx) -> Unit raise) -> Unit

    Setup::when1

    source
    fn[A : FromStepArg] Setup::when1(self : Setup, pattern : String, handler : (A) -> Unit raise) -> Unit

    Setup::when10

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] Setup::when10(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J) -> Unit raise) -> Unit

    Setup::when10_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] Setup::when10_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, Ctx) -> Unit raise) -> Unit

    Setup::when11

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] Setup::when11(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K) -> Unit raise) -> Unit

    Setup::when11_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] Setup::when11_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, Ctx) -> Unit raise) -> Unit

    Setup::when12

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] Setup::when12(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L) -> Unit raise) -> Unit

    Setup::when12_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] Setup::when12_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, Ctx) -> Unit raise) -> Unit

    Setup::when13

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] Setup::when13(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M) -> Unit raise) -> Unit

    Setup::when13_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] Setup::when13_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, Ctx) -> Unit raise) -> Unit

    Setup::when14

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] Setup::when14(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Unit raise) -> Unit

    Setup::when14_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] Setup::when14_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, Ctx) -> Unit raise) -> Unit

    Setup::when15

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] Setup::when15(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Unit raise) -> Unit

    Setup::when15_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] Setup::when15_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Ctx) -> Unit raise) -> Unit

    Setup::when16

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] Setup::when16(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Unit raise) -> Unit

    Setup::when16_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] Setup::when16_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Ctx) -> Unit raise) -> Unit

    Setup::when17

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] Setup::when17(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) -> Unit raise) -> Unit

    Setup::when17_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] Setup::when17_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Ctx) -> Unit raise) -> Unit

    Setup::when18

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] Setup::when18(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) -> Unit raise) -> Unit

    Setup::when18_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] Setup::when18_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Ctx) -> Unit raise) -> Unit

    Setup::when19

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] Setup::when19(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> Unit raise) -> Unit

    Setup::when19_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] Setup::when19_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Ctx) -> Unit raise) -> Unit

    Setup::when1_ctx

    source
    fn[A : FromStepArg] Setup::when1_ctx(self : Setup, pattern : String, handler : (A, Ctx) -> Unit raise) -> Unit

    Setup::when2

    source
    fn[A : FromStepArg, B : FromStepArg] Setup::when2(self : Setup, pattern : String, handler : (A, B) -> Unit raise) -> Unit

    Setup::when20

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] Setup::when20(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) -> Unit raise) -> Unit

    Setup::when20_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] Setup::when20_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Ctx) -> Unit raise) -> Unit

    Setup::when21

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] Setup::when21(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) -> Unit raise) -> Unit

    Setup::when21_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] Setup::when21_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Ctx) -> Unit raise) -> Unit

    Setup::when22

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] Setup::when22(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) -> Unit raise) -> Unit

    Setup::when22_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] Setup::when22_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Ctx) -> Unit raise) -> Unit

    Setup::when2_ctx

    source
    fn[A : FromStepArg, B : FromStepArg] Setup::when2_ctx(self : Setup, pattern : String, handler : (A, B, Ctx) -> Unit raise) -> Unit

    Setup::when3

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] Setup::when3(self : Setup, pattern : String, handler : (A, B, C) -> Unit raise) -> Unit

    Setup::when3_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] Setup::when3_ctx(self : Setup, pattern : String, handler : (A, B, C, Ctx) -> Unit raise) -> Unit

    Setup::when4

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] Setup::when4(self : Setup, pattern : String, handler : (A, B, C, D) -> Unit raise) -> Unit

    Setup::when4_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] Setup::when4_ctx(self : Setup, pattern : String, handler : (A, B, C, D, Ctx) -> Unit raise) -> Unit

    Setup::when5

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] Setup::when5(self : Setup, pattern : String, handler : (A, B, C, D, E) -> Unit raise) -> Unit

    Setup::when5_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] Setup::when5_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, Ctx) -> Unit raise) -> Unit

    Setup::when6

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] Setup::when6(self : Setup, pattern : String, handler : (A, B, C, D, E, F) -> Unit raise) -> Unit

    Setup::when6_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] Setup::when6_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, Ctx) -> Unit raise) -> Unit

    Setup::when7

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] Setup::when7(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G) -> Unit raise) -> Unit

    Setup::when7_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] Setup::when7_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, Ctx) -> Unit raise) -> Unit

    Setup::when8

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] Setup::when8(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H) -> Unit raise) -> Unit

    Setup::when8_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] Setup::when8_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, Ctx) -> Unit raise) -> Unit

    Setup::when9

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] Setup::when9(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I) -> Unit raise) -> Unit

    Setup::when9_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] Setup::when9_ctx(self : Setup, pattern : String, handler : (A, B, C, D, E, F, G, H, I, Ctx) -> Unit raise) -> Unit

    StepArg

    source
    pub(all) struct StepArg {
      value : StepValue
      raw : String
    }

    A step argument carrying both the typed value and the original matched text.
    impl Eq for StepArg
    impl Show for StepArg

    StepArg::from_param

    source

    Convert a cucumber-expressions Param to a StepArg.

    StepDef

    source
    pub(all) struct StepDef {
      keyword : StepKeyword
      pattern : String
      handler : StepHandler
      source : StepSource?
      id : StepDefId?
    }

    A first-class step definition: keyword, pattern, handler, and optional source.

    StepDef::given

    source
    fn StepDef::given(pattern : String, handler : (Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given0

    source
    fn StepDef::given0(pattern : String, handler : () -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given0_ctx

    source
    fn StepDef::given0_ctx(pattern : String, handler : (Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given1

    source
    fn[A : FromStepArg] StepDef::given1(pattern : String, handler : (A) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given10

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] StepDef::given10(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given10_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] StepDef::given10_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given11

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] StepDef::given11(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given11_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] StepDef::given11_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given12

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] StepDef::given12(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given12_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] StepDef::given12_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given13

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] StepDef::given13(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given13_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] StepDef::given13_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given14

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] StepDef::given14(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given14_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] StepDef::given14_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given15

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] StepDef::given15(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given15_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] StepDef::given15_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given16

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] StepDef::given16(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given16_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] StepDef::given16_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given17

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] StepDef::given17(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given17_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] StepDef::given17_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given18

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] StepDef::given18(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given18_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] StepDef::given18_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given19

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] StepDef::given19(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given19_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] StepDef::given19_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given1_ctx

    source
    fn[A : FromStepArg] StepDef::given1_ctx(pattern : String, handler : (A, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given2

    source
    fn[A : FromStepArg, B : FromStepArg] StepDef::given2(pattern : String, handler : (A, B) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given20

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] StepDef::given20(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given20_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] StepDef::given20_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given21

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] StepDef::given21(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given21_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] StepDef::given21_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given22

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] StepDef::given22(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given22_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] StepDef::given22_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given2_ctx

    source
    fn[A : FromStepArg, B : FromStepArg] StepDef::given2_ctx(pattern : String, handler : (A, B, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given3

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] StepDef::given3(pattern : String, handler : (A, B, C) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given3_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] StepDef::given3_ctx(pattern : String, handler : (A, B, C, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given4

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] StepDef::given4(pattern : String, handler : (A, B, C, D) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given4_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] StepDef::given4_ctx(pattern : String, handler : (A, B, C, D, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given5

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] StepDef::given5(pattern : String, handler : (A, B, C, D, E) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given5_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] StepDef::given5_ctx(pattern : String, handler : (A, B, C, D, E, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given6

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] StepDef::given6(pattern : String, handler : (A, B, C, D, E, F) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given6_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] StepDef::given6_ctx(pattern : String, handler : (A, B, C, D, E, F, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given7

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] StepDef::given7(pattern : String, handler : (A, B, C, D, E, F, G) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given7_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] StepDef::given7_ctx(pattern : String, handler : (A, B, C, D, E, F, G, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given8

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] StepDef::given8(pattern : String, handler : (A, B, C, D, E, F, G, H) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given8_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] StepDef::given8_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given9

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] StepDef::given9(pattern : String, handler : (A, B, C, D, E, F, G, H, I) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::given9_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] StepDef::given9_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step

    source
    fn StepDef::step(pattern : String, handler : (Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step0

    source
    fn StepDef::step0(pattern : String, handler : () -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step0_ctx

    source
    fn StepDef::step0_ctx(pattern : String, handler : (Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step1

    source
    fn[A : FromStepArg] StepDef::step1(pattern : String, handler : (A) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step10

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] StepDef::step10(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step10_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] StepDef::step10_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step11

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] StepDef::step11(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step11_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] StepDef::step11_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step12

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] StepDef::step12(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step12_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] StepDef::step12_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step13

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] StepDef::step13(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step13_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] StepDef::step13_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step14

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] StepDef::step14(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step14_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] StepDef::step14_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step15

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] StepDef::step15(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step15_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] StepDef::step15_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step16

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] StepDef::step16(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step16_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] StepDef::step16_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step17

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] StepDef::step17(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step17_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] StepDef::step17_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step18

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] StepDef::step18(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step18_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] StepDef::step18_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step19

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] StepDef::step19(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step19_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] StepDef::step19_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step1_ctx

    source
    fn[A : FromStepArg] StepDef::step1_ctx(pattern : String, handler : (A, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step2

    source
    fn[A : FromStepArg, B : FromStepArg] StepDef::step2(pattern : String, handler : (A, B) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step20

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] StepDef::step20(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step20_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] StepDef::step20_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step21

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] StepDef::step21(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step21_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] StepDef::step21_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step22

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] StepDef::step22(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step22_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] StepDef::step22_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step2_ctx

    source
    fn[A : FromStepArg, B : FromStepArg] StepDef::step2_ctx(pattern : String, handler : (A, B, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step3

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] StepDef::step3(pattern : String, handler : (A, B, C) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step3_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] StepDef::step3_ctx(pattern : String, handler : (A, B, C, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step4

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] StepDef::step4(pattern : String, handler : (A, B, C, D) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step4_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] StepDef::step4_ctx(pattern : String, handler : (A, B, C, D, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step5

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] StepDef::step5(pattern : String, handler : (A, B, C, D, E) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step5_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] StepDef::step5_ctx(pattern : String, handler : (A, B, C, D, E, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step6

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] StepDef::step6(pattern : String, handler : (A, B, C, D, E, F) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step6_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] StepDef::step6_ctx(pattern : String, handler : (A, B, C, D, E, F, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step7

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] StepDef::step7(pattern : String, handler : (A, B, C, D, E, F, G) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step7_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] StepDef::step7_ctx(pattern : String, handler : (A, B, C, D, E, F, G, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step8

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] StepDef::step8(pattern : String, handler : (A, B, C, D, E, F, G, H) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step8_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] StepDef::step8_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step9

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] StepDef::step9(pattern : String, handler : (A, B, C, D, E, F, G, H, I) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::step9_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] StepDef::step9_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then

    source
    fn StepDef::then(pattern : String, handler : (Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then0

    source
    fn StepDef::then0(pattern : String, handler : () -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then0_ctx

    source
    fn StepDef::then0_ctx(pattern : String, handler : (Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then1

    source
    fn[A : FromStepArg] StepDef::then1(pattern : String, handler : (A) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then10

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] StepDef::then10(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then10_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] StepDef::then10_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then11

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] StepDef::then11(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then11_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] StepDef::then11_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then12

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] StepDef::then12(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then12_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] StepDef::then12_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then13

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] StepDef::then13(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then13_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] StepDef::then13_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then14

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] StepDef::then14(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then14_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] StepDef::then14_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then15

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] StepDef::then15(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then15_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] StepDef::then15_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then16

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] StepDef::then16(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then16_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] StepDef::then16_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then17

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] StepDef::then17(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then17_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] StepDef::then17_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then18

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] StepDef::then18(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then18_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] StepDef::then18_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then19

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] StepDef::then19(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then19_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] StepDef::then19_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then1_ctx

    source
    fn[A : FromStepArg] StepDef::then1_ctx(pattern : String, handler : (A, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then2

    source
    fn[A : FromStepArg, B : FromStepArg] StepDef::then2(pattern : String, handler : (A, B) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then20

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] StepDef::then20(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then20_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] StepDef::then20_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then21

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] StepDef::then21(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then21_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] StepDef::then21_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then22

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] StepDef::then22(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then22_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] StepDef::then22_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then2_ctx

    source
    fn[A : FromStepArg, B : FromStepArg] StepDef::then2_ctx(pattern : String, handler : (A, B, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then3

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] StepDef::then3(pattern : String, handler : (A, B, C) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then3_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] StepDef::then3_ctx(pattern : String, handler : (A, B, C, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then4

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] StepDef::then4(pattern : String, handler : (A, B, C, D) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then4_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] StepDef::then4_ctx(pattern : String, handler : (A, B, C, D, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then5

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] StepDef::then5(pattern : String, handler : (A, B, C, D, E) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then5_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] StepDef::then5_ctx(pattern : String, handler : (A, B, C, D, E, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then6

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] StepDef::then6(pattern : String, handler : (A, B, C, D, E, F) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then6_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] StepDef::then6_ctx(pattern : String, handler : (A, B, C, D, E, F, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then7

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] StepDef::then7(pattern : String, handler : (A, B, C, D, E, F, G) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then7_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] StepDef::then7_ctx(pattern : String, handler : (A, B, C, D, E, F, G, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then8

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] StepDef::then8(pattern : String, handler : (A, B, C, D, E, F, G, H) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then8_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] StepDef::then8_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then9

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] StepDef::then9(pattern : String, handler : (A, B, C, D, E, F, G, H, I) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::then9_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] StepDef::then9_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when

    source
    fn StepDef::when(pattern : String, handler : (Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when0

    source
    fn StepDef::when0(pattern : String, handler : () -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when0_ctx

    source
    fn StepDef::when0_ctx(pattern : String, handler : (Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when1

    source
    fn[A : FromStepArg] StepDef::when1(pattern : String, handler : (A) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when10

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] StepDef::when10(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when10_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg] StepDef::when10_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when11

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] StepDef::when11(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when11_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg] StepDef::when11_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when12

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] StepDef::when12(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when12_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg] StepDef::when12_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when13

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] StepDef::when13(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when13_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg] StepDef::when13_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when14

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] StepDef::when14(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when14_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg] StepDef::when14_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when15

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] StepDef::when15(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when15_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg] StepDef::when15_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when16

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] StepDef::when16(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when16_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg] StepDef::when16_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when17

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] StepDef::when17(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when17_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg] StepDef::when17_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when18

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] StepDef::when18(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when18_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg] StepDef::when18_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when19

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] StepDef::when19(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when19_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg] StepDef::when19_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when1_ctx

    source
    fn[A : FromStepArg] StepDef::when1_ctx(pattern : String, handler : (A, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when2

    source
    fn[A : FromStepArg, B : FromStepArg] StepDef::when2(pattern : String, handler : (A, B) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when20

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] StepDef::when20(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when20_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg] StepDef::when20_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when21

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] StepDef::when21(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when21_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg] StepDef::when21_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when22

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] StepDef::when22(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when22_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg, J : FromStepArg, K : FromStepArg, L : FromStepArg, M : FromStepArg, N : FromStepArg, O : FromStepArg, P : FromStepArg, Q : FromStepArg, R : FromStepArg, S : FromStepArg, T : FromStepArg, U : FromStepArg, V : FromStepArg] StepDef::when22_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when2_ctx

    source
    fn[A : FromStepArg, B : FromStepArg] StepDef::when2_ctx(pattern : String, handler : (A, B, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when3

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] StepDef::when3(pattern : String, handler : (A, B, C) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when3_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg] StepDef::when3_ctx(pattern : String, handler : (A, B, C, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when4

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] StepDef::when4(pattern : String, handler : (A, B, C, D) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when4_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg] StepDef::when4_ctx(pattern : String, handler : (A, B, C, D, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when5

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] StepDef::when5(pattern : String, handler : (A, B, C, D, E) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when5_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg] StepDef::when5_ctx(pattern : String, handler : (A, B, C, D, E, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when6

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] StepDef::when6(pattern : String, handler : (A, B, C, D, E, F) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when6_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg] StepDef::when6_ctx(pattern : String, handler : (A, B, C, D, E, F, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when7

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] StepDef::when7(pattern : String, handler : (A, B, C, D, E, F, G) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when7_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg] StepDef::when7_ctx(pattern : String, handler : (A, B, C, D, E, F, G, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when8

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] StepDef::when8(pattern : String, handler : (A, B, C, D, E, F, G, H) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when8_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg] StepDef::when8_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when9

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] StepDef::when9(pattern : String, handler : (A, B, C, D, E, F, G, H, I) -> Unit raise, source? : StepSource) -> StepDef

    StepDef::when9_ctx

    source
    fn[A : FromStepArg, B : FromStepArg, C : FromStepArg, D : FromStepArg, E : FromStepArg, F : FromStepArg, G : FromStepArg, H : FromStepArg, I : FromStepArg] StepDef::when9_ctx(pattern : String, handler : (A, B, C, D, E, F, G, H, I, Ctx) -> Unit raise, source? : StepSource) -> StepDef

    StepDefId

    source
    pub(all) struct StepDefId {
      // private fields

      fn new(value : String) -> StepDefId
    }

    A unique identifier for a step definition, assigned by the StepRegistry.
    impl Eq for StepDefId
    impl Hash for StepDefId
    impl Show for StepDefId

    StepDefId::to_string

    source
    fn StepDefId::to_string(self : StepDefId) -> String

    StepHandler

    source
    pub type StepHandler (Ctx) -> Unit raise

    A step handler function that receives extracted arguments.

    StepHandler::inner

    source
    #deprecated("Use `struct T(A)` to declare a newtype and use `.0` access the underlying type instead.")
    fn StepHandler::inner(self : StepHandler) -> ((Ctx) -> Unit raise)
    Convert newtype to its underlying type, automatically derived.

    StepHookCtx

    source
    pub(all) struct StepHookCtx {
      // private fields
    }

    Hook context for test step-level hooks (before/after_test_step).

    StepHookCtx::attach

    source
    fn StepHookCtx::attach(self : StepHookCtx, body : String, media_type : String, file_name? : String) -> Unit

    StepHookCtx::attach_bytes

    source
    fn StepHookCtx::attach_bytes(self : StepHookCtx, data : Bytes, media_type : String, file_name? : String) -> Unit

    StepHookCtx::attach_url

    source
    fn StepHookCtx::attach_url(self : StepHookCtx, url : String, media_type : String) -> Unit

    StepHookCtx::new

    source
    fn StepHookCtx::new(scenario : ScenarioInfo, step : StepInfo) -> StepHookCtx

    StepHookCtx::pending_attachments

    source
    fn StepHookCtx::pending_attachments(self : StepHookCtx) -> Array[PendingAttachment]

    StepHookCtx::scenario

    source
    fn StepHookCtx::scenario(self : StepHookCtx) -> ScenarioInfo

    StepHookCtx::step

    source
    fn StepHookCtx::step(self : StepHookCtx) -> StepInfo

    StepInfo

    source
    pub(all) struct StepInfo {
      keyword : String
      text : String
    }

    Information about a step being executed.
    impl Eq for StepInfo
    impl Show for StepInfo

    StepKeyword

    source
    pub(all) enum StepKeyword {
      Given
      When
      Then
      Step
    }

    Keyword classification for a step definition.
    impl Eq for StepKeyword
    impl Show for StepKeyword

    StepMatchResult

    source
    pub(all) enum StepMatchResult {
      Matched(StepDef, Array[StepArg])
      Undefined(String, String, String, Array[String])
    }

    Result of matching step text against the registry.

    StepRegistry

    source
    pub(all) struct StepRegistry {
      // private fields
    }

    Registry of step definitions keyed by Cucumber Expression patterns.

    StepRegistry::find_match

    source
    fn StepRegistry::find_match(self : StepRegistry, text : String, keyword? : String) -> StepMatchResult

    Find a matching step definition for the given step text. Returns Matched with StepDef + extracted args, or Undefined with diagnostics.

    StepRegistry::len

    source
    fn StepRegistry::len(self : StepRegistry) -> Int

    Number of registered step definitions.

    StepRegistry::new

    source

    Create an empty step registry.

    StepRegistry::register_def

    source
    fn StepRegistry::register_def(self : StepRegistry, step_def : StepDef, param_registry : 
    ParamTypeRegistry    ) -> Unit

    Register a StepDef directly, using the given param registry for expression parsing.

    StepRegistry::step_defs

    source
    fn StepRegistry::step_defs(self : StepRegistry) -> Array[StepDef]

    Return all registered step definitions.

    StepRegistry::use_library

    source
    fn[L : StepLibrary] StepRegistry::use_library(self : StepRegistry, library : L, param_registry : 
    ParamTypeRegistry    ) -> Unit

    Compose a StepLibrary into this registry using the given param registry.

    StepSource

    source
    pub(all) struct StepSource {
      uri : String?
      line : Int?
    }

    Optional source location for a step definition (populated by codegen).
    impl Eq for StepSource
    impl Show for StepSource

    StepSource::new

    source
    fn StepSource::new(uri? : String, line? : Int) -> StepSource

    StepValue

    source
    pub(all) enum StepValue {
      IntVal(Int)
      FloatVal(Double)
      DoubleVal(Double)
      LongVal(Int64)
      ByteVal(Byte)
      ShortVal(Int)
      StringVal(String)
      WordVal(String)
      AnonymousVal(String)
      BigDecimalVal(
    Decimal    )
      BigIntegerVal(
    BigInt    )
      CustomVal(
    Any    )
      DocStringVal(DocString)
      DataTableVal(DataTable)
    }

    A typed value extracted from step text, pattern-matchable for built-in types.

    pending_step_error

    source
    fn pending_step_error(step~ : String, keyword~ : String, message~ : String) -> Error

    Create a PendingStep error.

    run_failed_error

    source
    fn run_failed_error(summary~ : String, errors~ : Array[MoonspecError]) -> Error

    Create a RunFailed error.

    scenario_failed_error

    source
    fn scenario_failed_error(scenario~ : String, feature~ : String, errors~ : Array[MoonspecError]) -> MoonspecError

    Create a ScenarioFailed error.

    step_failed_error

    source
    fn step_failed_error(step~ : String, keyword~ : String, message~ : String) -> Error

    Create a StepFailed error.

    undefined_step_error

    source
    fn undefined_step_error(step~ : String, keyword~ : String, snippet~ : String, suggestions~ : Array[String]) -> Error

    Create an UndefinedStep error.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io