Class StateCaptureError

A scripted state that failed while running: a selector that never appeared, an action that threw, a seeding request that returned the wrong status, or the whole state exceeding its budget.

stepIndex: -1 denotes a failure that no step is answerable for, with stepKind naming which one: "state" for navigation or the whole-state budget, "precondition" for a probe that could not be evaluated at all — a malformed selector, a page that went away. A precondition that is simply absent is not a failure and produces no error; the state is skipped.

Hierarchy

{ state: string } & { message: string } & { cause: unknown } & {
    _tag: "StateCaptureError";
} & { stepIndex: number } & { stepKind: string } & { target: string } & Omit<
    {},
    | "state"
    | "message"
    | "cause"
    | "_tag"
    | "stepIndex"
    | "stepKind"
    | "target",
> & YieldableError<this>
- StateCaptureError

Index

Constructors

constructor

new StateCaptureError(
    props: {
        state: string;
        stepIndex: number;
        stepKind: string;
        target: string;
        message: string;
        cause: unknown;
    },
    options?: MakeOptions,
): StateCaptureError
Parameters
- props: {
      state: string;
      stepIndex: number;
      stepKind: string;
      target: string;
      message: string;
      cause: unknown;
  }
- Optionaloptions: MakeOptions
Returns StateCaptureError
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).constructor
- Defined in node_modules/@effect/schema/dist/dts/Schema.d.ts:3944

Properties

`Static` `Readonly`Type

Type: StateCaptureError

`Static` `Readonly`Encoded

Encoded: {
    state: string;
    message: string;
    cause: unknown;
    _tag: "StateCaptureError";
    stepIndex: number;
    stepKind: string;
    target: string;
}

`Static` `Readonly`Context

Context: never

Since

0.69.3

`Static` `Readonly`[TypeId]

"[TypeId]": {
    _A: Invariant<StateCaptureError>;
    _I: Invariant<
        {
            state: string;
            message: string;
            cause: unknown;
            _tag: "StateCaptureError";
            stepIndex: number;
            stepKind: string;
            target: string;
        },
    >;
    _R: Covariant<never>;
}

`Static` `Readonly`ast

ast: Transformation

Since

0.69.3

`Static` `Readonly`fields

fields: {
    _tag: tag<"StateCaptureError">;
    state: typeof String$;
    stepIndex: typeof Number$;
    stepKind: typeof String$;
    target: typeof String$;
    message: typeof String$;
    cause: typeof Unknown;
}

`Static` `Readonly`identifier

identifier: string

`Static` `Readonly`_tag

_tag: "StateCaptureError"

`Readonly`_tag

_tag: "StateCaptureError"

`Readonly`state

state: string = S.String

`Readonly`stepIndex

stepIndex: number = S.Number

`Readonly`stepKind

stepKind: string = S.String

`Readonly`target

target: string = S.String

message

message: string = S.String

cause

cause: unknown = S.Unknown

`Readonly`[EffectTypeId]

"[EffectTypeId]": VarianceStruct<never, StateCaptureError, never>

`Readonly`[StreamTypeId]

"[StreamTypeId]": VarianceStruct<never, StateCaptureError, never>

`Readonly`[SinkTypeId]

"[SinkTypeId]": VarianceStruct<never, unknown, never, StateCaptureError, never>

`Readonly`[ChannelTypeId]

"[ChannelTypeId]": VarianceStruct<
    never,
    unknown,
    StateCaptureError,
    unknown,
    never,
    unknown,
    never,
>

name

name: string

`Optional`stack

stack?: string

Methods

`Static`make

make<Args extends any[], X>(this: new (...args: Args) => X, ...args: Args): X
Type Parameters
- Args extends any[]
- X
Parameters
- this: new (...args: Args) => X
- ...args: Args
Returns X
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).make
- Defined in node_modules/@effect/schema/dist/dts/Schema.d.ts:3947

`Static`annotations

annotations(
    annotations: Schema<StateCaptureError>,
): SchemaClass<
    StateCaptureError,
    {
        state: string;
        message: string;
        cause: unknown;
        _tag: "StateCaptureError";
        stepIndex: number;
        stepKind: string;
        target: string;
    },
    never,
>
Merges a set of new annotations with existing ones, potentially overwriting any duplicates.
Parameters
- annotations: Schema<StateCaptureError>
Returns SchemaClass<
    StateCaptureError,
    {
        state: string;
        message: string;
        cause: unknown;
        _tag: "StateCaptureError";
        stepIndex: number;
        stepKind: string;
        target: string;
    },
    never,
>
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).annotations
- Defined in node_modules/@effect/schema/dist/dts/Schema.d.ts:3950

`Static`extend

extend<Extended = never>(
    identifier: string,
): <newFields extends Fields>(
    fields: newFields | HasFields<newFields>,
    annotations?: Schema<Extended, readonly []>,
) => [Extended] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.extend<Self>()({ ... })`"
    : Class<
        Extended,
        { _tag: tag<"StateCaptureError"> } & {
            state: typeof String$;
            stepIndex: typeof Number$;
            stepKind: typeof String$;
            target: typeof String$;
            message: typeof String$;
            cause: typeof Unknown;
        } & newFields,
        {
            state: string;
            message: string;
            cause: unknown;
            _tag: "StateCaptureError";
            stepIndex: number;
            stepKind: string;
            target: string;
        } & {} & {
            readonly [K in string
            | number
            | symbol as Key<newFields, K>]: Encoded<newFields[K]>
        } & {
            readonly [K in string
            | number
            | symbol as Key<newFields, K>]?: Encoded<newFields[K]>
        },
        Context<newFields[keyof newFields]>,
        { state: string } & { message: string } & { cause: unknown } & {
            stepIndex: number;
        } & { stepKind: string } & { target: string } & Constructor<newFields>,
        StateCaptureError,
        YieldableError,
    >
Type Parameters
- Extended = never
Parameters
- identifier: string
Returns <newFields extends Fields>(
    fields: newFields | HasFields<newFields>,
    annotations?: Schema<Extended, readonly []>,
) => [Extended] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.extend<Self>()({ ... })`"
    : Class<
        Extended,
        { _tag: tag<"StateCaptureError"> } & {
            state: typeof String$;
            stepIndex: typeof Number$;
            stepKind: typeof String$;
            target: typeof String$;
            message: typeof String$;
            cause: typeof Unknown;
        } & newFields,
        {
            state: string;
            message: string;
            cause: unknown;
            _tag: "StateCaptureError";
            stepIndex: number;
            stepKind: string;
            target: string;
        } & {} & {
            readonly [K in string
            | number
            | symbol as Key<newFields, K>]: Encoded<newFields[K]>
        } & {
            readonly [K in string
            | number
            | symbol as Key<newFields, K>]?: Encoded<newFields[K]>
        },
        Context<newFields[keyof newFields]>,
        { state: string } & { message: string } & { cause: unknown } & {
            stepIndex: number;
        } & { stepKind: string } & { target: string } & Constructor<newFields>,
        StateCaptureError,
        YieldableError,
    >
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).extend
- Defined in node_modules/@effect/schema/dist/dts/Schema.d.ts:3955

`Static`transformOrFail

transformOrFail<Transformed = never>(
    identifier: string,
): <newFields extends Fields, R2, R3>(
    fields: newFields,
    options: {
        decode: (
            input: {
                _tag: "StateCaptureError";
                state: string;
                stepIndex: number;
                stepKind: string;
                target: string;
                message: string;
                cause: unknown;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: Type<
                    { _tag: tag<"StateCaptureError"> } & {
                        state: typeof String$;
                        stepIndex: typeof Number$;
                        stepKind: typeof String$;
                        target: typeof String$;
                        message: typeof String$;
                        cause: typeof Unknown;
                    } & newFields,
                >[K]
            },
            ParseIssue,
            R2,
        >;
        encode: (
            input: {
                [K in string | number | symbol]: Type<
                    { _tag: tag<"StateCaptureError"> } & {
                        state: typeof String$;
                        stepIndex: typeof Number$;
                        stepKind: typeof String$;
                        target: typeof String$;
                        message: typeof String$;
                        cause: typeof Unknown;
                    } & newFields,
                >[K]
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            { state: string } & { message: string } & { cause: unknown } & {
                _tag: "StateCaptureError";
            } & { stepIndex: number } & { stepKind: string } & { target: string },
            ParseIssue,
            R3,
        >;
    },
    annotations?: Schema<Transformed, readonly []>,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`"
    : Class<
        Transformed,
        { _tag: tag<"StateCaptureError"> } & {
            state: typeof String$;
            stepIndex: typeof Number$;
            stepKind: typeof String$;
            target: typeof String$;
            message: typeof String$;
            cause: typeof Unknown;
        } & newFields,
        Encoded<
            { _tag: tag<"StateCaptureError"> } & {
                state: typeof String$;
                stepIndex: typeof Number$;
                stepKind: typeof String$;
                target: typeof String$;
                message: typeof String$;
                cause: typeof Unknown;
            },
        >,
        R2
        | R3
        | Context<newFields[keyof newFields]>,
        { state: string } & { message: string } & { cause: unknown } & {
            stepIndex: number;
        } & { stepKind: string } & { target: string } & Constructor<newFields>,
        StateCaptureError,
        YieldableError,
    >
Type Parameters
- Transformed = never
Parameters
- identifier: string
Returns <newFields extends Fields, R2, R3>(
    fields: newFields,
    options: {
        decode: (
            input: {
                _tag: "StateCaptureError";
                state: string;
                stepIndex: number;
                stepKind: string;
                target: string;
                message: string;
                cause: unknown;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: Type<
                    { _tag: tag<"StateCaptureError"> } & {
                        state: typeof String$;
                        stepIndex: typeof Number$;
                        stepKind: typeof String$;
                        target: typeof String$;
                        message: typeof String$;
                        cause: typeof Unknown;
                    } & newFields,
                >[K]
            },
            ParseIssue,
            R2,
        >;
        encode: (
            input: {
                [K in string | number | symbol]: Type<
                    { _tag: tag<"StateCaptureError"> } & {
                        state: typeof String$;
                        stepIndex: typeof Number$;
                        stepKind: typeof String$;
                        target: typeof String$;
                        message: typeof String$;
                        cause: typeof Unknown;
                    } & newFields,
                >[K]
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            { state: string } & { message: string } & { cause: unknown } & {
                _tag: "StateCaptureError";
            } & { stepIndex: number } & { stepKind: string } & { target: string },
            ParseIssue,
            R3,
        >;
    },
    annotations?: Schema<Transformed, readonly []>,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`"
    : Class<
        Transformed,
        { _tag: tag<"StateCaptureError"> } & {
            state: typeof String$;
            stepIndex: typeof Number$;
            stepKind: typeof String$;
            target: typeof String$;
            message: typeof String$;
            cause: typeof Unknown;
        } & newFields,
        Encoded<
            { _tag: tag<"StateCaptureError"> } & {
                state: typeof String$;
                stepIndex: typeof Number$;
                stepKind: typeof String$;
                target: typeof String$;
                message: typeof String$;
                cause: typeof Unknown;
            },
        >,
        R2
        | R3
        | Context<newFields[keyof newFields]>,
        { state: string } & { message: string } & { cause: unknown } & {
            stepIndex: number;
        } & { stepKind: string } & { target: string } & Constructor<newFields>,
        StateCaptureError,
        YieldableError,
    >
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).transformOrFail
- Defined in node_modules/@effect/schema/dist/dts/Schema.d.ts:3956

`Static`transformOrFailFrom

transformOrFailFrom<Transformed = never>(
    identifier: string,
): <newFields extends Fields, R2, R3>(
    fields: newFields,
    options: {
        decode: (
            input: {
                state: string;
                message: string;
                cause: unknown;
                _tag: "StateCaptureError";
                stepIndex: number;
                stepKind: string;
                target: string;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: (
                    {
                        state: string;
                        message: string;
                        cause: unknown;
                        _tag: "StateCaptureError";
                        stepIndex: number;
                        stepKind: string;
                        target: string;
                    } & {} & {
                        readonly [K in string
                        | number
                        | symbol as Key<newFields, K>]: Encoded<newFields[K]>
                    } & {
                        readonly [K in string
                        | number
                        | symbol as Key<newFields, K>]?: Encoded<(...)[(...)]>
                    }
                )[K]
            },
            ParseIssue,
            R2,
        >;
        encode: (
            input: {
                [K in string | number | symbol]: (
                    {
                        state: string;
                        message: string;
                        cause: unknown;
                        _tag: "StateCaptureError";
                        stepIndex: number;
                        stepKind: string;
                        target: string;
                    } & {} & {
                        readonly [K in string
                        | number
                        | symbol as Key<newFields, K>]: Encoded<newFields[K]>
                    } & {
                        readonly [K in string
                        | number
                        | symbol as Key<newFields, K>]?: Encoded<newFields[K]>
                    }
                )[K]
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            Encoded<
                { _tag: tag<"StateCaptureError"> } & {
                    state: typeof String$;
                    stepIndex: typeof Number$;
                    stepKind: typeof String$;
                    target: typeof String$;
                    message: typeof String$;
                    cause: typeof Unknown;
                },
            >,
            ParseIssue,
            R3,
        >;
    },
    annotations?: Schema<Transformed, readonly []>,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`"
    : Class<
        Transformed,
        { _tag: tag<"StateCaptureError"> } & {
            state: typeof String$;
            stepIndex: typeof Number$;
            stepKind: typeof String$;
            target: typeof String$;
            message: typeof String$;
            cause: typeof Unknown;
        } & newFields,
        Encoded<
            { _tag: tag<"StateCaptureError"> } & {
                state: typeof String$;
                stepIndex: typeof Number$;
                stepKind: typeof String$;
                target: typeof String$;
                message: typeof String$;
                cause: typeof Unknown;
            },
        >,
        R2
        | R3
        | Context<newFields[keyof newFields]>,
        { state: string } & { message: string } & { cause: unknown } & {
            stepIndex: number;
        } & { stepKind: string } & { target: string } & Constructor<newFields>,
        StateCaptureError,
        YieldableError,
    >
Type Parameters
- Transformed = never
Parameters
- identifier: string
Returns <newFields extends Fields, R2, R3>(
    fields: newFields,
    options: {
        decode: (
            input: {
                state: string;
                message: string;
                cause: unknown;
                _tag: "StateCaptureError";
                stepIndex: number;
                stepKind: string;
                target: string;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: (
                    {
                        state: string;
                        message: string;
                        cause: unknown;
                        _tag: "StateCaptureError";
                        stepIndex: number;
                        stepKind: string;
                        target: string;
                    } & {} & {
                        readonly [K in string
                        | number
                        | symbol as Key<newFields, K>]: Encoded<newFields[K]>
                    } & {
                        readonly [K in string
                        | number
                        | symbol as Key<newFields, K>]?: Encoded<(...)[(...)]>
                    }
                )[K]
            },
            ParseIssue,
            R2,
        >;
        encode: (
            input: {
                [K in string | number | symbol]: (
                    {
                        state: string;
                        message: string;
                        cause: unknown;
                        _tag: "StateCaptureError";
                        stepIndex: number;
                        stepKind: string;
                        target: string;
                    } & {} & {
                        readonly [K in string
                        | number
                        | symbol as Key<newFields, K>]: Encoded<newFields[K]>
                    } & {
                        readonly [K in string
                        | number
                        | symbol as Key<newFields, K>]?: Encoded<newFields[K]>
                    }
                )[K]
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            Encoded<
                { _tag: tag<"StateCaptureError"> } & {
                    state: typeof String$;
                    stepIndex: typeof Number$;
                    stepKind: typeof String$;
                    target: typeof String$;
                    message: typeof String$;
                    cause: typeof Unknown;
                },
            >,
            ParseIssue,
            R3,
        >;
    },
    annotations?: Schema<Transformed, readonly []>,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`"
    : Class<
        Transformed,
        { _tag: tag<"StateCaptureError"> } & {
            state: typeof String$;
            stepIndex: typeof Number$;
            stepKind: typeof String$;
            target: typeof String$;
            message: typeof String$;
            cause: typeof Unknown;
        } & newFields,
        Encoded<
            { _tag: tag<"StateCaptureError"> } & {
                state: typeof String$;
                stepIndex: typeof Number$;
                stepKind: typeof String$;
                target: typeof String$;
                message: typeof String$;
                cause: typeof Unknown;
            },
        >,
        R2
        | R3
        | Context<newFields[keyof newFields]>,
        { state: string } & { message: string } & { cause: unknown } & {
            stepIndex: number;
        } & { stepKind: string } & { target: string } & Constructor<newFields>,
        StateCaptureError,
        YieldableError,
    >
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).transformOrFailFrom
- Defined in node_modules/@effect/schema/dist/dts/Schema.d.ts:3960

[iterator]

"[iterator]"(): EffectGenerator<Effect<never, StateCaptureError, never>>
Returns EffectGenerator<Effect<never, StateCaptureError, never>>
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).[iterator]
- Defined in node_modules/effect/dist/dts/Cause.d.ts:286

toString

toString(): string
Returns string
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).toString
- Defined in node_modules/effect/dist/dts/Inspectable.d.ts:20

toJSON

toJSON(): unknown
Returns unknown
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).toJSON
- Defined in node_modules/effect/dist/dts/Inspectable.d.ts:21

[NodeInspectSymbol]

"[NodeInspectSymbol]"(): unknown
Returns unknown
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).[NodeInspectSymbol]
- Defined in node_modules/effect/dist/dts/Inspectable.d.ts:22

`Static`pipe

pipe<A>(this: A): A
Type Parameters
- A
Parameters
- this: A
Returns A
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:10
pipe<A, B = never>(this: A, ab: (_: A) => B): B
Type Parameters
- A
- B = never
Parameters
- this: A
- ab: (_: A) => B
Returns B
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:11
pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C
Type Parameters
- A
- B = never
- C = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
Returns C
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:12
pipe<A, B = never, C = never, D = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
): D
Type Parameters
- A
- B = never
- C = never
- D = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
Returns D
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:13
pipe<A, B = never, C = never, D = never, E = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
): E
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
Returns E
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:14
pipe<A, B = never, C = never, D = never, E = never, F = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
): F
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
Returns F
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:15
pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
): G
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
Returns G
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:16
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
): H
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
Returns H
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:17
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
): I
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
Returns I
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:18
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
): J
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
Returns J
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:19
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
): K
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
Returns K
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:20
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
): L
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
Returns L
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:21
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
): M
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
Returns M
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:22
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
): N
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
Returns N
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:23
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
): O
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
Returns O
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:24
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
): P
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
Returns P
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:25
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
): Q
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
Returns Q
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:26
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
): R
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
Returns R
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:27
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
): S
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
Returns S
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:28
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
): T
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
Returns T
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:29
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:30
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:31

pipe

pipe<A>(this: A): A
Type Parameters
- A
Parameters
- this: A
Returns A
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:10
pipe<A, B = never>(this: A, ab: (_: A) => B): B
Type Parameters
- A
- B = never
Parameters
- this: A
- ab: (_: A) => B
Returns B
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:11
pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C
Type Parameters
- A
- B = never
- C = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
Returns C
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:12
pipe<A, B = never, C = never, D = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
): D
Type Parameters
- A
- B = never
- C = never
- D = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
Returns D
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:13
pipe<A, B = never, C = never, D = never, E = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
): E
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
Returns E
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:14
pipe<A, B = never, C = never, D = never, E = never, F = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
): F
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
Returns F
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:15
pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
): G
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
Returns G
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:16
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
): H
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
Returns H
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:17
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
): I
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
Returns I
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:18
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
): J
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
Returns J
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:19
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
): K
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
Returns K
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:20
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
): L
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
Returns L
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:21
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
): M
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
Returns M
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:22
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
): N
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
Returns N
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:23
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
): O
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
Returns O
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:24
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
): P
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
Returns P
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:25
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
): Q
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
Returns Q
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:26
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
): R
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
Returns R
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:27
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
): S
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
Returns S
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:28
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
): T
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
Returns T
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:29
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:30
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from S.TaggedError<StateCaptureError>()( "StateCaptureError", { state: S.String, stepIndex: S.Number, stepKind: S.String, target: S.String, message: S.String, cause: S.Unknown, }, ).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:31

Class StateCaptureError

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns StateCaptureError

Properties

Static ReadonlyType

Static ReadonlyEncoded

Static ReadonlyContext

Since

Static Readonly[TypeId]

Static Readonlyast

Since

Static Readonlyfields

Static Readonlyidentifier

Static Readonly_tag

Readonly_tag

Readonlystate

ReadonlystepIndex

ReadonlystepKind

Readonlytarget

message

cause

Readonly[EffectTypeId]

Readonly[StreamTypeId]

Readonly[SinkTypeId]

Readonly[ChannelTypeId]

name

Optionalstack

Methods

Staticmake

Type Parameters

Parameters

Returns X

Staticannotations

Parameters

Returns SchemaClass< StateCaptureError, { state: string; message: string; cause: unknown; _tag: "StateCaptureError"; stepIndex: number; stepKind: string; target: string; }, never,>

Staticextend

Type Parameters

Parameters

StatictransformOrFail

Type Parameters

Parameters

StatictransformOrFailFrom

Type Parameters

Parameters

[iterator]

Returns EffectGenerator<Effect<never, StateCaptureError, never>>

toString

Returns string

toJSON

Returns unknown

[NodeInspectSymbol]

Returns unknown

Staticpipe

Type Parameters

Parameters

Returns A

Type Parameters

Parameters

Returns B

Type Parameters

Parameters

Returns C

Type Parameters

Parameters

Returns D

Type Parameters

Parameters

Returns E

Type Parameters

Parameters

Returns F

Type Parameters

Parameters

`Static` `Readonly`Type

`Static` `Readonly`Encoded

`Static` `Readonly`Context

`Static` `Readonly`[TypeId]

`Static` `Readonly`ast

`Static` `Readonly`fields

`Static` `Readonly`identifier

`Static` `Readonly`_tag

`Readonly`_tag

`Readonly`state

`Readonly`stepIndex

`Readonly`stepKind

`Readonly`target

`Readonly`[EffectTypeId]

`Readonly`[StreamTypeId]

`Readonly`[SinkTypeId]

`Readonly`[ChannelTypeId]

`Optional`stack

`Static`make

`Static`annotations

Returns SchemaClass<
StateCaptureError,
{
state: string;
message: string;
cause: unknown;
_tag: "StateCaptureError";
stepIndex: number;
stepKind: string;
target: string;
},
never,
>

`Static`extend

`Static`transformOrFail

`Static`transformOrFailFrom

`Static`pipe