@elysiumoss/ui-capture - v0.3.0
    Preparing search index...

    Class WaitForStep

    Wait for a selector to reach a DOM state. This is also the assertion mechanism: if the dialog never opens, the state fails rather than screenshotting the boot view and reporting success.

    Hierarchy

    • { selector: string } & { kind: "waitFor" } & {
          state: "visible" | "hidden" | "attached" | "detached";
      } & { minCount?: number } & { optional: boolean } & { timeoutMs?: number } & {
          settleMs?: number;
      } & Omit<
          {},
          | "selector"
          | "kind"
          | "state"
          | "minCount"
          | "optional"
          | "timeoutMs"
          | "settleMs",
      >
      • WaitForStep
    Index
    constructor
    Type Encoded Context [TypeId] ast fields identifier optional timeoutMs? settleMs? kind selector state minCount?
    make annotations extend transformOrFail transformOrFailFrom pipe

    • Parameters

      • props: {
            optional?: boolean;
            timeoutMs?: number;
            settleMs?: number;
            kind: "waitFor";
            selector: string;
            state?: "visible" | "hidden" | "attached" | "detached";
            minCount?: 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: "waitFor"
        • Readonlyselector: string
        • Optional Readonlystate?: "visible" | "hidden" | "attached" | "detached"
        • Optional ReadonlyminCount?: number

          Require at least this many matches. Waiting for one .fleet-row and shooting a half-populated fleet is exactly the "looks like coverage" failure scripted states exist to eliminate.

      • Optionaloptions: MakeOptions

      Returns WaitForStep

    Type: WaitForStep
    Encoded: {
        selector: string;
        kind: "waitFor";
        state?: "visible" | "hidden" | "attached" | "detached";
        minCount?: number;
        optional?: boolean;
        timeoutMs?: number;
        settleMs?: number;
    }
    Context: never

    0.69.3

    "[TypeId]": {
        _A: Invariant<WaitForStep>;
        _I: Invariant<
            {
                selector: string;
                kind: "waitFor";
                state?: "visible"
                | "hidden"
                | "attached"
                | "detached";
                minCount?: number;
                optional?: boolean;
                timeoutMs?: number;
                settleMs?: number;
            },
        >;
        _R: Covariant<never>;
    }
    ast: Transformation

    0.69.3

    fields: {
        optional: optionalWith<typeof Boolean$, { default: () => false }>;
        timeoutMs: optional<filter<Schema<number, number, never>>>;
        settleMs: optional<filter<Schema<number, number, never>>>;
        kind: Literal<["waitFor"]>;
        selector: typeof String$;
        state: optionalWith<
            Literal<["visible", "hidden", "attached", "detached"]>,
            { default: () => "visible" },
        >;
        minCount: 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<["waitFor"]>
    • Readonlyselector: typeof String$
    • Readonlystate: optionalWith<
          Literal<["visible", "hidden", "attached", "detached"]>,
          { default: () => "visible" },
      >
    • ReadonlyminCount: optional<filter<Schema<number, number, never>>>

      Require at least this many matches. Waiting for one .fleet-row and shooting a half-populated fleet is exactly the "looks like coverage" failure scripted states exist to eliminate.

    identifier: string
    optional: boolean = ...

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

    timeoutMs?: number = ...

    Per-step timeout override (default: 5000).

    settleMs?: number = ...

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

    kind: "waitFor" = ...
    selector: string = S.String
    state: "visible" | "hidden" | "attached" | "detached" = ...
    minCount?: number = ...

    Require at least this many matches. Waiting for one .fleet-row and shooting a half-populated fleet is exactly the "looks like coverage" failure scripted states exist to eliminate.

    • Type Parameters

      • Args extends any[]
      • X

      Parameters

      • this: new (...args: Args) => X
      • ...args: Args

      Returns X

    • Merges a set of new annotations with existing ones, potentially overwriting any duplicates.

      Parameters

      Returns SchemaClass<
          WaitForStep,
          {
              selector: string;
              kind: "waitFor";
              state?: "visible"
              | "hidden"
              | "attached"
              | "detached";
              minCount?: number;
              optional?: boolean;
              timeoutMs?: number;
              settleMs?: number;
          },
          never,
      >

    • 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<["waitFor"]>;
                  selector: typeof String$;
                  state: optionalWith<
                      Literal<["visible", "hidden", "attached", "detached"]>,
                      { default: () => "visible" },
                  >;
                  minCount: optional<filter<Schema<number, number, never>>>;
              } & newFields,
              { selector: string; kind: "waitFor" } & {
                  state?: "visible" | "hidden" | "attached" | "detached";
                  minCount?: number;
                  optional?: boolean;
                  timeoutMs?: number;
                  settleMs?: 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]>,
              { selector: string } & { kind: "waitFor" } & {
                  state?: "visible" | "hidden" | "attached" | "detached";
              } & { minCount?: number } & { optional?: boolean } & {
                  timeoutMs?: number;
              } & { settleMs?: number } & Constructor<newFields>,
              WaitForStep,
              {},
          >

    • 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: "waitFor";
                      selector: string;
                      state: "visible" | "hidden" | "attached" | "detached";
                      minCount?: 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<[(...)]>;
                              selector: typeof String$;
                              state: optionalWith<Literal<(...)>, { default: ... }>;
                              minCount: 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<["waitFor"]>;
                              selector: typeof String$;
                              state: optionalWith<
                                  Literal<[(...), (...), (...), (...)]>,
                                  { default: () => ... },
                              >;
                              minCount: optional<filter<Schema<(...), (...), (...)>>>;
                          } & newFields,
                      >[K]
                  },
                  options: ParseOptions,
                  ast: Transformation,
              ) => Effect<
                  { selector: string } & { kind: "waitFor" } & {
                      state: "visible" | "hidden" | "attached" | "detached";
                  } & { minCount?: number } & { optional: boolean } & {
                      timeoutMs?: number;
                  } & { settleMs?: 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<["waitFor"]>;
                  selector: typeof String$;
                  state: optionalWith<
                      Literal<["visible", "hidden", "attached", "detached"]>,
                      { default: () => "visible" },
                  >;
                  minCount: 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<["waitFor"]>;
                      selector: typeof String$;
                      state: optionalWith<
                          Literal<["visible", "hidden", "attached", "detached"]>,
                          { default: () => "visible" },
                      >;
                      minCount: optional<filter<Schema<number, number, never>>>;
                  },
              >,
              R2
              | R3
              | Context<newFields[keyof newFields]>,
              { selector: string } & { kind: "waitFor" } & {
                  state?: "visible" | "hidden" | "attached" | "detached";
              } & { minCount?: number } & { optional?: boolean } & {
                  timeoutMs?: number;
              } & { settleMs?: number } & Constructor<newFields>,
              WaitForStep,
              {},
          >

    • Type Parameters

      • Transformed = never

      Parameters

      • identifier: string

      Returns <newFields extends Fields, R2, R3>(
          fields: newFields,
          options: {
              decode: (
                  input: {
                      selector: string;
                      kind: "waitFor";
                      state?: "visible" | "hidden" | "attached" | "detached";
                      minCount?: number;
                      optional?: boolean;
                      timeoutMs?: number;
                      settleMs?: number;
                  },
                  options: ParseOptions,
                  ast: Transformation,
              ) => Effect<
                  {
                      [K in string
                      | number
                      | symbol]: (
                          { selector: string; kind: "waitFor" } & {
                              state?: "visible" | "hidden" | "attached" | "detached";
                              minCount?: number;
                              optional?: boolean;
                              timeoutMs?: number;
                              settleMs?: 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]: (
                          { selector: string; kind: "waitFor" } & {
                              state?: "visible" | "hidden" | "attached" | "detached";
                              minCount?: number;
                              optional?: boolean;
                              timeoutMs?: number;
                              settleMs?: 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<["waitFor"]>;
                          selector: typeof String$;
                          state: optionalWith<
                              Literal<["visible", "hidden", "attached", "detached"]>,
                              { default: () => "visible" },
                          >;
                          minCount: 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<["waitFor"]>;
                  selector: typeof String$;
                  state: optionalWith<
                      Literal<["visible", "hidden", "attached", "detached"]>,
                      { default: () => "visible" },
                  >;
                  minCount: 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<["waitFor"]>;
                      selector: typeof String$;
                      state: optionalWith<
                          Literal<["visible", "hidden", "attached", "detached"]>,
                          { default: () => "visible" },
                      >;
                      minCount: optional<filter<Schema<number, number, never>>>;
                  },
              >,
              R2
              | R3
              | Context<newFields[keyof newFields]>,
              { selector: string } & { kind: "waitFor" } & {
                  state?: "visible" | "hidden" | "attached" | "detached";
              } & { minCount?: number } & { optional?: boolean } & {
                  timeoutMs?: number;
              } & { settleMs?: number } & Constructor<newFields>,
              WaitForStep,
              {},
          >

    • Type Parameters

      • A

      Parameters

      • this: A

      Returns A

    • Type Parameters

      • A
      • B = never

      Parameters

      • this: A
      • ab: (_: A) => B

      Returns B

    • Type Parameters

      • A
      • B = never
      • C = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C

      Returns C

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D

      Returns D

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    Settings
    Member Visibility

    On This Page
    Constructors
    Properties
    Methods