Class RequestStep

Seed application state through the app's own API, using the page's browser context so the request inherits its session cookie and origin.

path is resolved against the page URL, making it same-origin by construction; the crawler's host filter is applied as a second gate. Runs only when allowStateRequests is enabled (--allow-state-requests).

Hierarchy

{ kind: "request" } & { optional: boolean } & { timeoutMs?: number } & {
    settleMs?: number;
} & { path: string } & {
    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
} & { json?: unknown } & { headers?: { readonly [key: string]: string } } & {
    expectStatus?: number;
} & Omit<
    {},
    | "kind"
    | "optional"
    | "timeoutMs"
    | "settleMs"
    | "path"
    | "method"
    | "json"
    | "headers"
    | "expectStatus",
>
- RequestStep

Index

Constructors

constructor

new RequestStep(
    props: {
        optional?: boolean;
        timeoutMs?: number;
        settleMs?: number;
        kind: "request";
        method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
        path: string;
        json?: unknown;
        headers?: { readonly [key: string]: string };
        expectStatus?: number;
    },
    options?: MakeOptions,
): RequestStep
Parameters
- props: {
      optional?: boolean;
      timeoutMs?: number;
      settleMs?: number;
      kind: "request";
      method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
      path: string;
      json?: unknown;
      headers?: { readonly [key: string]: string };
      expectStatus?: number;
  }
  - Optional Readonlyoptional?: boolean
    
    Log and skip this step on failure instead of failing the whole state.
  - Optional ReadonlytimeoutMs?: number
    
    Per-step timeout override (default: 5000).
  - Optional ReadonlysettleMs?: number
    
    Pause after the step succeeds, for animation/transition settling.
  - Readonlykind: "request"
  - Readonlymethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE"
  - Readonlypath: string
    
    Resolved against the page URL. Absolute URLs must stay same-host.
  - Optional Readonlyjson?: unknown
  - Optional Readonlyheaders?: { readonly [key: string]: string }
  - Optional ReadonlyexpectStatus?: number
    
    Defaults to "any 2xx". A seed that silently 500s fails the state.
- Optionaloptions: MakeOptions
Returns RequestStep
Inherited from S.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).constructor
- Defined in node_modules/@effect/schema/dist/dts/Schema.d.ts:3944

Properties

`Static` `Readonly`Type

Type: RequestStep

`Static` `Readonly`Encoded

Encoded: {
    kind: "request";
    path: string;
    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
    optional?: boolean;
    timeoutMs?: number;
    settleMs?: number;
    json?: unknown;
    headers?: { readonly [key: string]: string };
    expectStatus?: number;
}

`Static` `Readonly`Context

Context: never

Since

0.69.3

`Static` `Readonly`[TypeId]

"[TypeId]": {
    _A: Invariant<RequestStep>;
    _I: Invariant<
        {
            kind: "request";
            path: string;
            method: "GET"
            | "POST"
            | "PUT"
            | "PATCH"
            | "DELETE";
            optional?: boolean;
            timeoutMs?: number;
            settleMs?: number;
            json?: unknown;
            headers?: { readonly [key: string]: string };
            expectStatus?: number;
        },
    >;
    _R: Covariant<never>;
}

`Static` `Readonly`ast

ast: Transformation

Since

0.69.3

`Static` `Readonly`fields

fields: {
    optional: optionalWith<typeof Boolean$, { default: () => false }>;
    timeoutMs: optional<filter<Schema<number, number, never>>>;
    settleMs: optional<filter<Schema<number, number, never>>>;
    kind: Literal<["request"]>;
    method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: typeof String$;
    json: optional<typeof Unknown>;
    headers: optional<Record$<typeof String$, typeof String$>>;
    expectStatus: optional<filter<Schema<number, number, never>>>;
}

Type Declaration

Readonlyoptional: optionalWith<typeof Boolean$, { default: () => false }>

Log and skip this step on failure instead of failing the whole state.
ReadonlytimeoutMs: optional<filter<Schema<number, number, never>>>

Per-step timeout override (default: 5000).
ReadonlysettleMs: optional<filter<Schema<number, number, never>>>

Pause after the step succeeds, for animation/transition settling.
Readonlykind: Literal<["request"]>
Readonlymethod: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>
Readonlypath: typeof String$

Resolved against the page URL. Absolute URLs must stay same-host.
Readonlyjson: optional<typeof Unknown>
Readonlyheaders: optional<Record$<typeof String$, typeof String$>>
ReadonlyexpectStatus: optional<filter<Schema<number, number, never>>>

Defaults to "any 2xx". A seed that silently 500s fails the state.

`Static` `Readonly`identifier

identifier: string

`Readonly`optional

optional: boolean = ...

Log and skip this step on failure instead of failing the whole state.

`Optional` `Readonly`timeoutMs

timeoutMs?: number = ...

Per-step timeout override (default: 5000).

`Optional` `Readonly`settleMs

settleMs?: number = ...

Pause after the step succeeds, for animation/transition settling.

`Readonly`kind

kind: "request" = ...

`Readonly`method

method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" = ...

`Readonly`path

path: string = S.String

Resolved against the page URL. Absolute URLs must stay same-host.

`Optional` `Readonly`json

json?: unknown = ...

`Optional` `Readonly`headers

headers?: { readonly [key: string]: string } = ...

`Optional` `Readonly`expectStatus

expectStatus?: number = ...

Defaults to "any 2xx". A seed that silently 500s fails the state.

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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).make
- Defined in node_modules/@effect/schema/dist/dts/Schema.d.ts:3947

`Static`annotations

annotations(
    annotations: Schema<RequestStep>,
): SchemaClass<
    RequestStep,
    {
        kind: "request";
        path: string;
        method: "GET"
        | "POST"
        | "PUT"
        | "PATCH"
        | "DELETE";
        optional?: boolean;
        timeoutMs?: number;
        settleMs?: number;
        json?: unknown;
        headers?: { readonly [key: string]: string };
        expectStatus?: number;
    },
    never,
>
Merges a set of new annotations with existing ones, potentially overwriting any duplicates.
Parameters
- annotations: Schema<RequestStep>
Returns SchemaClass<
    RequestStep,
    {
        kind: "request";
        path: string;
        method: "GET"
        | "POST"
        | "PUT"
        | "PATCH"
        | "DELETE";
        optional?: boolean;
        timeoutMs?: number;
        settleMs?: number;
        json?: unknown;
        headers?: { readonly [key: string]: string };
        expectStatus?: number;
    },
    never,
>
Inherited from S.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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,
        {
            optional: optionalWith<typeof Boolean$, { default: () => false }>;
            timeoutMs: optional<filter<Schema<number, number, never>>>;
            settleMs: optional<filter<Schema<number, number, never>>>;
            kind: Literal<["request"]>;
            method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
            path: typeof String$;
            json: optional<typeof Unknown>;
            headers: optional<Record$<typeof String$, typeof String$>>;
            expectStatus: optional<filter<Schema<number, number, never>>>;
        } & newFields,
        {
            kind: "request";
            path: string;
            method: "GET"
            | "POST"
            | "PUT"
            | "PATCH"
            | "DELETE";
        } & {
            optional?: boolean;
            timeoutMs?: number;
            settleMs?: number;
            json?: unknown;
            headers?: { readonly [key: string]: string };
            expectStatus?: number;
        } & {
            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]>,
        { kind: "request" } & { optional?: boolean } & { timeoutMs?: number } & {
            settleMs?: number;
        } & { path: string } & {
            method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
        } & { json?: unknown } & { headers?: { readonly [key: string]: string } } & {
            expectStatus?: number;
        } & Constructor<newFields>,
        RequestStep,
        {},
    >
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,
        {
            optional: optionalWith<typeof Boolean$, { default: () => false }>;
            timeoutMs: optional<filter<Schema<number, number, never>>>;
            settleMs: optional<filter<Schema<number, number, never>>>;
            kind: Literal<["request"]>;
            method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
            path: typeof String$;
            json: optional<typeof Unknown>;
            headers: optional<Record$<typeof String$, typeof String$>>;
            expectStatus: optional<filter<Schema<number, number, never>>>;
        } & newFields,
        {
            kind: "request";
            path: string;
            method: "GET"
            | "POST"
            | "PUT"
            | "PATCH"
            | "DELETE";
        } & {
            optional?: boolean;
            timeoutMs?: number;
            settleMs?: number;
            json?: unknown;
            headers?: { readonly [key: string]: string };
            expectStatus?: number;
        } & {
            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]>,
        { kind: "request" } & { optional?: boolean } & { timeoutMs?: number } & {
            settleMs?: number;
        } & { path: string } & {
            method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
        } & { json?: unknown } & { headers?: { readonly [key: string]: string } } & {
            expectStatus?: number;
        } & Constructor<newFields>,
        RequestStep,
        {},
    >
Inherited from S.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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: {
                optional: boolean;
                timeoutMs?: number;
                settleMs?: number;
                kind: "request";
                method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
                path: string;
                json?: unknown;
                headers?: { readonly [key: string]: string };
                expectStatus?: number;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: Type<
                    {
                        optional: optionalWith<typeof Boolean$, { default: ... }>;
                        timeoutMs: optional<filter<(...)>>;
                        settleMs: optional<filter<(...)>>;
                        kind: Literal<[(...)]>;
                        method: Literal<[(...), (...), (...), (...), (...)]>;
                        path: typeof String$;
                        json: optional<typeof Unknown>;
                        headers: optional<Record$<(...), (...)>>;
                        expectStatus: optional<filter<(...)>>;
                    } & newFields,
                >[K]
            },
            ParseIssue,
            R2,
        >;
        encode: (
            input: {
                [K in string | number | symbol]: Type<
                    {
                        optional: optionalWith<typeof Boolean$, { default: () => ... }>;
                        timeoutMs: optional<filter<Schema<(...), (...), (...)>>>;
                        settleMs: optional<filter<Schema<(...), (...), (...)>>>;
                        kind: Literal<["request"]>;
                        method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
                        path: typeof String$;
                        json: optional<typeof Unknown>;
                        headers: optional<Record$<typeof String$, typeof String$>>;
                        expectStatus: optional<filter<Schema<(...), (...), (...)>>>;
                    } & newFields,
                >[K]
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            { kind: "request" } & { optional: boolean } & { timeoutMs?: number } & {
                settleMs?: number;
            } & { path: string } & {
                method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
            } & { json?: unknown } & { headers?: { readonly [key: string]: string } } & {
                expectStatus?: number;
            },
            ParseIssue,
            R3,
        >;
    },
    annotations?: Schema<Transformed, readonly []>,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`"
    : Class<
        Transformed,
        {
            optional: optionalWith<typeof Boolean$, { default: () => false }>;
            timeoutMs: optional<filter<Schema<number, number, never>>>;
            settleMs: optional<filter<Schema<number, number, never>>>;
            kind: Literal<["request"]>;
            method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
            path: typeof String$;
            json: optional<typeof Unknown>;
            headers: optional<Record$<typeof String$, typeof String$>>;
            expectStatus: optional<filter<Schema<number, number, never>>>;
        } & newFields,
        Encoded<
            {
                optional: optionalWith<typeof Boolean$, { default: () => false }>;
                timeoutMs: optional<filter<Schema<number, number, never>>>;
                settleMs: optional<filter<Schema<number, number, never>>>;
                kind: Literal<["request"]>;
                method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
                path: typeof String$;
                json: optional<typeof Unknown>;
                headers: optional<Record$<typeof String$, typeof String$>>;
                expectStatus: optional<filter<Schema<number, number, never>>>;
            },
        >,
        R2
        | R3
        | Context<newFields[keyof newFields]>,
        { kind: "request" } & { optional?: boolean } & { timeoutMs?: number } & {
            settleMs?: number;
        } & { path: string } & {
            method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
        } & { json?: unknown } & { headers?: { readonly [key: string]: string } } & {
            expectStatus?: number;
        } & Constructor<newFields>,
        RequestStep,
        {},
    >
Type Parameters
- Transformed = never
Parameters
- identifier: string
Returns <newFields extends Fields, R2, R3>(
    fields: newFields,
    options: {
        decode: (
            input: {
                optional: boolean;
                timeoutMs?: number;
                settleMs?: number;
                kind: "request";
                method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
                path: string;
                json?: unknown;
                headers?: { readonly [key: string]: string };
                expectStatus?: number;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: Type<
                    {
                        optional: optionalWith<typeof Boolean$, { default: ... }>;
                        timeoutMs: optional<filter<(...)>>;
                        settleMs: optional<filter<(...)>>;
                        kind: Literal<[(...)]>;
                        method: Literal<[(...), (...), (...), (...), (...)]>;
                        path: typeof String$;
                        json: optional<typeof Unknown>;
                        headers: optional<Record$<(...), (...)>>;
                        expectStatus: optional<filter<(...)>>;
                    } & newFields,
                >[K]
            },
            ParseIssue,
            R2,
        >;
        encode: (
            input: {
                [K in string | number | symbol]: Type<
                    {
                        optional: optionalWith<typeof Boolean$, { default: () => ... }>;
                        timeoutMs: optional<filter<Schema<(...), (...), (...)>>>;
                        settleMs: optional<filter<Schema<(...), (...), (...)>>>;
                        kind: Literal<["request"]>;
                        method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
                        path: typeof String$;
                        json: optional<typeof Unknown>;
                        headers: optional<Record$<typeof String$, typeof String$>>;
                        expectStatus: optional<filter<Schema<(...), (...), (...)>>>;
                    } & newFields,
                >[K]
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            { kind: "request" } & { optional: boolean } & { timeoutMs?: number } & {
                settleMs?: number;
            } & { path: string } & {
                method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
            } & { json?: unknown } & { headers?: { readonly [key: string]: string } } & {
                expectStatus?: number;
            },
            ParseIssue,
            R3,
        >;
    },
    annotations?: Schema<Transformed, readonly []>,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`"
    : Class<
        Transformed,
        {
            optional: optionalWith<typeof Boolean$, { default: () => false }>;
            timeoutMs: optional<filter<Schema<number, number, never>>>;
            settleMs: optional<filter<Schema<number, number, never>>>;
            kind: Literal<["request"]>;
            method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
            path: typeof String$;
            json: optional<typeof Unknown>;
            headers: optional<Record$<typeof String$, typeof String$>>;
            expectStatus: optional<filter<Schema<number, number, never>>>;
        } & newFields,
        Encoded<
            {
                optional: optionalWith<typeof Boolean$, { default: () => false }>;
                timeoutMs: optional<filter<Schema<number, number, never>>>;
                settleMs: optional<filter<Schema<number, number, never>>>;
                kind: Literal<["request"]>;
                method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
                path: typeof String$;
                json: optional<typeof Unknown>;
                headers: optional<Record$<typeof String$, typeof String$>>;
                expectStatus: optional<filter<Schema<number, number, never>>>;
            },
        >,
        R2
        | R3
        | Context<newFields[keyof newFields]>,
        { kind: "request" } & { optional?: boolean } & { timeoutMs?: number } & {
            settleMs?: number;
        } & { path: string } & {
            method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
        } & { json?: unknown } & { headers?: { readonly [key: string]: string } } & {
            expectStatus?: number;
        } & Constructor<newFields>,
        RequestStep,
        {},
    >
Inherited from S.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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: {
                kind: "request";
                path: string;
                method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
                optional?: boolean;
                timeoutMs?: number;
                settleMs?: number;
                json?: unknown;
                headers?: { readonly [key: string]: string };
                expectStatus?: number;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: (
                    {
                        kind: "request";
                        path: string;
                        method: "GET"
                        | "POST"
                        | "PUT"
                        | "PATCH"
                        | "DELETE";
                    } & {
                        optional?: boolean;
                        timeoutMs?: number;
                        settleMs?: number;
                        json?: unknown;
                        headers?: { readonly [key: string]: string };
                        expectStatus?: number;
                    } & {
                        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]: (
                    {
                        kind: "request";
                        path: string;
                        method: "GET"
                        | "POST"
                        | "PUT"
                        | "PATCH"
                        | "DELETE";
                    } & {
                        optional?: boolean;
                        timeoutMs?: number;
                        settleMs?: number;
                        json?: unknown;
                        headers?: { readonly [key: string]: string };
                        expectStatus?: number;
                    } & {
                        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<
                {
                    optional: optionalWith<typeof Boolean$, { default: () => false }>;
                    timeoutMs: optional<filter<Schema<number, number, never>>>;
                    settleMs: optional<filter<Schema<number, number, never>>>;
                    kind: Literal<["request"]>;
                    method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
                    path: typeof String$;
                    json: optional<typeof Unknown>;
                    headers: optional<Record$<typeof String$, typeof String$>>;
                    expectStatus: optional<filter<Schema<number, number, never>>>;
                },
            >,
            ParseIssue,
            R3,
        >;
    },
    annotations?: Schema<Transformed, readonly []>,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`"
    : Class<
        Transformed,
        {
            optional: optionalWith<typeof Boolean$, { default: () => false }>;
            timeoutMs: optional<filter<Schema<number, number, never>>>;
            settleMs: optional<filter<Schema<number, number, never>>>;
            kind: Literal<["request"]>;
            method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
            path: typeof String$;
            json: optional<typeof Unknown>;
            headers: optional<Record$<typeof String$, typeof String$>>;
            expectStatus: optional<filter<Schema<number, number, never>>>;
        } & newFields,
        Encoded<
            {
                optional: optionalWith<typeof Boolean$, { default: () => false }>;
                timeoutMs: optional<filter<Schema<number, number, never>>>;
                settleMs: optional<filter<Schema<number, number, never>>>;
                kind: Literal<["request"]>;
                method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
                path: typeof String$;
                json: optional<typeof Unknown>;
                headers: optional<Record$<typeof String$, typeof String$>>;
                expectStatus: optional<filter<Schema<number, number, never>>>;
            },
        >,
        R2
        | R3
        | Context<newFields[keyof newFields]>,
        { kind: "request" } & { optional?: boolean } & { timeoutMs?: number } & {
            settleMs?: number;
        } & { path: string } & {
            method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
        } & { json?: unknown } & { headers?: { readonly [key: string]: string } } & {
            expectStatus?: number;
        } & Constructor<newFields>,
        RequestStep,
        {},
    >
Type Parameters
- Transformed = never
Parameters
- identifier: string
Returns <newFields extends Fields, R2, R3>(
    fields: newFields,
    options: {
        decode: (
            input: {
                kind: "request";
                path: string;
                method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
                optional?: boolean;
                timeoutMs?: number;
                settleMs?: number;
                json?: unknown;
                headers?: { readonly [key: string]: string };
                expectStatus?: number;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: (
                    {
                        kind: "request";
                        path: string;
                        method: "GET"
                        | "POST"
                        | "PUT"
                        | "PATCH"
                        | "DELETE";
                    } & {
                        optional?: boolean;
                        timeoutMs?: number;
                        settleMs?: number;
                        json?: unknown;
                        headers?: { readonly [key: string]: string };
                        expectStatus?: number;
                    } & {
                        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]: (
                    {
                        kind: "request";
                        path: string;
                        method: "GET"
                        | "POST"
                        | "PUT"
                        | "PATCH"
                        | "DELETE";
                    } & {
                        optional?: boolean;
                        timeoutMs?: number;
                        settleMs?: number;
                        json?: unknown;
                        headers?: { readonly [key: string]: string };
                        expectStatus?: number;
                    } & {
                        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<
                {
                    optional: optionalWith<typeof Boolean$, { default: () => false }>;
                    timeoutMs: optional<filter<Schema<number, number, never>>>;
                    settleMs: optional<filter<Schema<number, number, never>>>;
                    kind: Literal<["request"]>;
                    method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
                    path: typeof String$;
                    json: optional<typeof Unknown>;
                    headers: optional<Record$<typeof String$, typeof String$>>;
                    expectStatus: optional<filter<Schema<number, number, never>>>;
                },
            >,
            ParseIssue,
            R3,
        >;
    },
    annotations?: Schema<Transformed, readonly []>,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`"
    : Class<
        Transformed,
        {
            optional: optionalWith<typeof Boolean$, { default: () => false }>;
            timeoutMs: optional<filter<Schema<number, number, never>>>;
            settleMs: optional<filter<Schema<number, number, never>>>;
            kind: Literal<["request"]>;
            method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
            path: typeof String$;
            json: optional<typeof Unknown>;
            headers: optional<Record$<typeof String$, typeof String$>>;
            expectStatus: optional<filter<Schema<number, number, never>>>;
        } & newFields,
        Encoded<
            {
                optional: optionalWith<typeof Boolean$, { default: () => false }>;
                timeoutMs: optional<filter<Schema<number, number, never>>>;
                settleMs: optional<filter<Schema<number, number, never>>>;
                kind: Literal<["request"]>;
                method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
                path: typeof String$;
                json: optional<typeof Unknown>;
                headers: optional<Record$<typeof String$, typeof String$>>;
                expectStatus: optional<filter<Schema<number, number, never>>>;
            },
        >,
        R2
        | R3
        | Context<newFields[keyof newFields]>,
        { kind: "request" } & { optional?: boolean } & { timeoutMs?: number } & {
            settleMs?: number;
        } & { path: string } & {
            method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
        } & { json?: unknown } & { headers?: { readonly [key: string]: string } } & {
            expectStatus?: number;
        } & Constructor<newFields>,
        RequestStep,
        {},
    >
Inherited from S.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).transformOrFailFrom
- Defined in node_modules/@effect/schema/dist/dts/Schema.d.ts:3960

`Static`pipe

pipe<A>(this: A): A
Type Parameters
- A
Parameters
- this: A
Returns A
Inherited from S.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).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.Class<RequestStep>("RequestStep")({ kind: S.Literal("request"), method: S.Literal("GET", "POST", "PUT", "PATCH", "DELETE"), /** Resolved against the page URL. Absolute URLs must stay same-host. */ path: S.String, json: S.optional(S.Unknown), headers: S.optional(S.Record({ key: S.String, value: S.String })), /** Defaults to "any 2xx". A seed that silently 500s fails the state. */ expectStatus: S.optional(S.Number.pipe(S.int(), S.positive())), ...StepBaseFields, }).pipe
- Defined in node_modules/effect/dist/dts/Pipeable.d.ts:31

Class RequestStep

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Optional Readonlyoptional?: boolean

Optional ReadonlytimeoutMs?: number

Optional ReadonlysettleMs?: number

Readonlykind: "request"

Readonlymethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE"

Readonlypath: string

Optional Readonlyjson?: unknown

Optional Readonlyheaders?: { readonly [key: string]: string }

Optional ReadonlyexpectStatus?: number

Returns RequestStep

Properties

Static ReadonlyType

Static ReadonlyEncoded

Static ReadonlyContext

Since

Static Readonly[TypeId]

Static Readonlyast

Since

Static Readonlyfields

Type Declaration

Readonlyoptional: optionalWith<typeof Boolean$, { default: () => false }>

ReadonlytimeoutMs: optional<filter<Schema<number, number, never>>>

ReadonlysettleMs: optional<filter<Schema<number, number, never>>>

Readonlykind: Literal<["request"]>

Readonlymethod: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>

Readonlypath: typeof String$

Readonlyjson: optional<typeof Unknown>

Readonlyheaders: optional<Record$<typeof String$, typeof String$>>

ReadonlyexpectStatus: optional<filter<Schema<number, number, never>>>

Static Readonlyidentifier

Readonlyoptional

Optional ReadonlytimeoutMs

Optional ReadonlysettleMs

Readonlykind

Readonlymethod

Readonlypath

Optional Readonlyjson

Optional Readonlyheaders

Optional ReadonlyexpectStatus

Methods

Staticmake

Type Parameters

Parameters

Returns X

Staticannotations

Parameters

Returns SchemaClass< RequestStep, { kind: "request"; path: string; method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE"; optional?: boolean; timeoutMs?: number; settleMs?: number; json?: unknown; headers?: { readonly [key: string]: string }; expectStatus?: number; }, never,>

Staticextend

Type Parameters

Parameters

StatictransformOrFail

Type Parameters

Parameters

StatictransformOrFailFrom

Type Parameters

Parameters

Staticpipe

Type Parameters

Parameters

Returns A

Type Parameters

Parameters

Returns B

Type Parameters

Parameters

Returns C

Type Parameters

Parameters

Returns D

Type Parameters

Parameters

`Optional` `Readonly`optional?: boolean

`Optional` `Readonly`timeoutMs?: number

`Optional` `Readonly`settleMs?: number

`Readonly`kind: "request"

`Readonly`method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE"

`Readonly`path: string

`Optional` `Readonly`json?: unknown

`Optional` `Readonly`headers?: { readonly [key: string]: string }

`Optional` `Readonly`expectStatus?: number

`Static` `Readonly`Type

`Static` `Readonly`Encoded

`Static` `Readonly`Context

`Static` `Readonly`[TypeId]

`Static` `Readonly`ast

`Static` `Readonly`fields

`Readonly`optional: optionalWith<typeof Boolean$, { default: () => false }>

`Readonly`timeoutMs: optional<filter<Schema<number, number, never>>>

`Readonly`settleMs: optional<filter<Schema<number, number, never>>>

`Readonly`kind: Literal<["request"]>

`Readonly`method: Literal<["GET", "POST", "PUT", "PATCH", "DELETE"]>

`Readonly`path: typeof String$

`Readonly`json: optional<typeof Unknown>

`Readonly`headers: optional<Record$<typeof String$, typeof String$>>

`Readonly`expectStatus: optional<filter<Schema<number, number, never>>>

`Static` `Readonly`identifier

`Readonly`optional

`Optional` `Readonly`timeoutMs

`Optional` `Readonly`settleMs

`Readonly`kind

`Readonly`method

`Readonly`path

`Optional` `Readonly`json

`Optional` `Readonly`headers

`Optional` `Readonly`expectStatus

`Static`make

`Static`annotations

Returns SchemaClass<
RequestStep,
{
kind: "request";
path: string;
method: "GET"
| "POST"
| "PUT"
| "PATCH"
| "DELETE";
optional?: boolean;
timeoutMs?: number;
settleMs?: number;
json?: unknown;
headers?: { readonly [key: string]: string };
expectStatus?: number;
},
never,
>

`Static`extend

`Static`transformOrFail

`Static`transformOrFailFrom

`Static`pipe