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

    Class CaptureResult

    Hierarchy

    • { state?: string } & { url: string } & { route: string } & {
          stateStatus?: "captured" | "skipped" | "failed";
      } & { failedStepIndex?: number } & {
          screenshots: { readonly [key: string]: ScreenshotPaths };
      } & { videos?: { readonly [key: string]: VideoQualityPaths } } & {
          videoErrors?: readonly string[];
      } & { error?: string } & { timestamp: number } & Omit<
          {},
          | "state"
          | "url"
          | "route"
          | "stateStatus"
          | "failedStepIndex"
          | "screenshots"
          | "videos"
          | "videoErrors"
          | "error"
          | "timestamp",
      >
      • CaptureResult
    Index
    constructor
    Type Encoded Context [TypeId] ast fields identifier url route state? stateStatus? failedStepIndex? screenshots videos? videoErrors? error? timestamp
    make annotations extend transformOrFail transformOrFailFrom pipe

    • Parameters

      • props: {
            url: string;
            route: string;
            state?: string;
            stateStatus?: "captured" | "skipped" | "failed";
            failedStepIndex?: number;
            screenshots: { readonly [key: string]: ScreenshotPaths };
            videos?: { readonly [key: string]: VideoQualityPaths };
            videoErrors?: readonly string[];
            error?: string;
            timestamp: number;
        }
        • Readonlyurl: string
        • Readonlyroute: string
        • Optional Readonlystate?: string

          Set only for scripted-state captures; absent for crawled routes.

        • Optional ReadonlystateStatus?: "captured" | "skipped" | "failed"
        • Optional ReadonlyfailedStepIndex?: number

          Index of the step that failed; -1 for a whole-state failure.

        • Readonlyscreenshots: { readonly [key: string]: ScreenshotPaths }
        • Optional Readonlyvideos?: { readonly [key: string]: VideoQualityPaths }
        • Optional ReadonlyvideoErrors?: readonly string[]

          Per-viewport video failures on a capture whose screenshots landed.

          A failed recording does not un-write the stills that are already on disk, so it is reported here rather than through error: the capture stays a success and says what it lost, instead of discarding good work and counting as a failure that produced nothing.

        • Optional Readonlyerror?: string
        • Readonlytimestamp: number
      • Optionaloptions: MakeOptions

      Returns CaptureResult

    Type: CaptureResult
    Encoded: {
        url: string;
        route: string;
        screenshots: {
            readonly [key: string]: { png: string; webp: string; jpg: string };
        };
        timestamp: number;
        state?: string;
        stateStatus?: "captured"
        | "skipped"
        | "failed";
        failedStepIndex?: number;
        videos?: {
            readonly [key: string]: { high: string; medium: string; low: string };
        };
        videoErrors?: readonly string[];
        error?: string;
    }
    Context: never

    0.69.3

    "[TypeId]": {
        _A: Invariant<CaptureResult>;
        _I: Invariant<
            {
                url: string;
                route: string;
                screenshots: {
                    readonly [key: string]: { png: string; webp: string; jpg: string };
                };
                timestamp: number;
                state?: string;
                stateStatus?: "captured"
                | "skipped"
                | "failed";
                failedStepIndex?: number;
                videos?: {
                    readonly [key: string]: { high: string; medium: string; low: string };
                };
                videoErrors?: readonly string[];
                error?: string;
            },
        >;
        _R: Covariant<never>;
    }
    ast: Transformation

    0.69.3

    fields: {
        url: typeof String$;
        route: typeof String$;
        state: optional<typeof String$>;
        stateStatus: optional<Literal<["captured", "skipped", "failed"]>>;
        failedStepIndex: optional<filter<Schema<number, number, never>>>;
        screenshots: Record$<typeof String$, typeof ScreenshotPaths>;
        videos: optional<Record$<typeof String$, typeof VideoQualityPaths>>;
        videoErrors: optional<Array$<typeof String$>>;
        error: optional<typeof String$>;
        timestamp: filter<Schema<number, number, never>>;
    }

    Type Declaration

    • Readonlyurl: typeof String$
    • Readonlyroute: typeof String$
    • Readonlystate: optional<typeof String$>

      Set only for scripted-state captures; absent for crawled routes.

    • ReadonlystateStatus: optional<Literal<["captured", "skipped", "failed"]>>
    • ReadonlyfailedStepIndex: optional<filter<Schema<number, number, never>>>

      Index of the step that failed; -1 for a whole-state failure.

    • Readonlyscreenshots: Record$<typeof String$, typeof ScreenshotPaths>
    • Readonlyvideos: optional<Record$<typeof String$, typeof VideoQualityPaths>>
    • ReadonlyvideoErrors: optional<Array$<typeof String$>>

      Per-viewport video failures on a capture whose screenshots landed.

      A failed recording does not un-write the stills that are already on disk, so it is reported here rather than through error: the capture stays a success and says what it lost, instead of discarding good work and counting as a failure that produced nothing.

    • Readonlyerror: optional<typeof String$>
    • Readonlytimestamp: filter<Schema<number, number, never>>
    identifier: string
    url: string = S.String
    route: string = S.String
    state?: string = ...

    Set only for scripted-state captures; absent for crawled routes.

    stateStatus?: "captured" | "skipped" | "failed" = ...
    failedStepIndex?: number = ...

    Index of the step that failed; -1 for a whole-state failure.

    screenshots: { readonly [key: string]: ScreenshotPaths } = ...
    videos?: { readonly [key: string]: VideoQualityPaths } = ...
    videoErrors?: readonly string[] = ...

    Per-viewport video failures on a capture whose screenshots landed.

    A failed recording does not un-write the stills that are already on disk, so it is reported here rather than through error: the capture stays a success and says what it lost, instead of discarding good work and counting as a failure that produced nothing.

    error?: string = ...
    timestamp: number = ...

    • 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<
          CaptureResult,
          {
              url: string;
              route: string;
              screenshots: {
                  readonly [key: string]: { png: string; webp: string; jpg: string };
              };
              timestamp: number;
              state?: string;
              stateStatus?: "captured"
              | "skipped"
              | "failed";
              failedStepIndex?: number;
              videos?: {
                  readonly [key: string]: { high: string; medium: string; low: string };
              };
              videoErrors?: readonly string[];
              error?: string;
          },
          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,
              {
                  url: typeof String$;
                  route: typeof String$;
                  state: optional<typeof String$>;
                  stateStatus: optional<Literal<["captured", "skipped", "failed"]>>;
                  failedStepIndex: optional<filter<Schema<number, number, never>>>;
                  screenshots: Record$<typeof String$, typeof ScreenshotPaths>;
                  videos: optional<Record$<typeof String$, typeof VideoQualityPaths>>;
                  videoErrors: optional<Array$<typeof String$>>;
                  error: optional<typeof String$>;
                  timestamp: filter<Schema<number, number, never>>;
              } & newFields,
              {
                  url: string;
                  route: string;
                  screenshots: {
                      readonly [key: string]: { png: string; webp: string; jpg: string };
                  };
                  timestamp: number;
              } & {
                  state?: string;
                  stateStatus?: "captured"
                  | "skipped"
                  | "failed";
                  failedStepIndex?: number;
                  videos?: {
                      readonly [key: string]: { high: string; medium: string; low: string };
                  };
                  videoErrors?: readonly string[];
                  error?: string;
              } & {
                  readonly [K in string
                  | number
                  | symbol as Key<newFields, K>]: Encoded<newFields[K]>
              } & {
                  readonly [K in string
                  | number
                  | symbol as Key<newFields, K>]?: Encoded<newFields[K]>
              },
              Context<newFields[keyof newFields]>,
              { state?: string } & { url: string } & { route: string } & {
                  stateStatus?: "captured" | "skipped" | "failed";
              } & { failedStepIndex?: number } & {
                  screenshots: { readonly [key: string]: ScreenshotPaths };
              } & { videos?: { readonly [key: string]: VideoQualityPaths } } & {
                  videoErrors?: readonly string[];
              } & { error?: string } & { timestamp: number } & Constructor<newFields>,
              CaptureResult,
              {},
          >

    • Type Parameters

      • Transformed = never

      Parameters

      • identifier: string

      Returns <newFields extends Fields, R2, R3>(
          fields: newFields,
          options: {
              decode: (
                  input: {
                      url: string;
                      route: string;
                      state?: string;
                      stateStatus?: "captured" | "skipped" | "failed";
                      failedStepIndex?: number;
                      screenshots: { readonly [key: string]: ScreenshotPaths };
                      videos?: { readonly [key: string]: VideoQualityPaths };
                      videoErrors?: readonly string[];
                      error?: string;
                      timestamp: number;
                  },
                  options: ParseOptions,
                  ast: Transformation,
              ) => Effect<
                  {
                      [K in string
                      | number
                      | symbol]: Type<
                          {
                              url: typeof String$;
                              route: typeof String$;
                              state: optional<typeof String$>;
                              stateStatus: optional<Literal<(...)>>;
                              failedStepIndex: optional<filter<(...)>>;
                              screenshots: Record$<typeof String$, typeof ScreenshotPaths>;
                              videos: optional<Record$<(...), (...)>>;
                              videoErrors: optional<Array$<(...)>>;
                              error: optional<typeof String$>;
                              timestamp: filter<Schema<(...), (...), (...)>>;
                          } & newFields,
                      >[K]
                  },
                  ParseIssue,
                  R2,
              >;
              encode: (
                  input: {
                      [K in string | number | symbol]: Type<
                          {
                              url: typeof String$;
                              route: typeof String$;
                              state: optional<typeof String$>;
                              stateStatus: optional<Literal<[(...), (...), (...)]>>;
                              failedStepIndex: optional<filter<Schema<(...), (...), (...)>>>;
                              screenshots: Record$<typeof String$, typeof ScreenshotPaths>;
                              videos: optional<Record$<typeof String$, typeof VideoQualityPaths>>;
                              videoErrors: optional<Array$<typeof String$>>;
                              error: optional<typeof String$>;
                              timestamp: filter<Schema<number, number, never>>;
                          } & newFields,
                      >[K]
                  },
                  options: ParseOptions,
                  ast: Transformation,
              ) => Effect<
                  { state?: string } & { url: string } & { route: string } & {
                      stateStatus?: "captured" | "skipped" | "failed";
                  } & { failedStepIndex?: number } & {
                      screenshots: { readonly [key: string]: ScreenshotPaths };
                  } & { videos?: { readonly [key: string]: VideoQualityPaths } } & {
                      videoErrors?: readonly string[];
                  } & { error?: string } & { timestamp: number },
                  ParseIssue,
                  R3,
              >;
          },
          annotations?: Schema<Transformed, readonly []>,
      ) => [Transformed] extends [never]
          ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`"
          : Class<
              Transformed,
              {
                  url: typeof String$;
                  route: typeof String$;
                  state: optional<typeof String$>;
                  stateStatus: optional<Literal<["captured", "skipped", "failed"]>>;
                  failedStepIndex: optional<filter<Schema<number, number, never>>>;
                  screenshots: Record$<typeof String$, typeof ScreenshotPaths>;
                  videos: optional<Record$<typeof String$, typeof VideoQualityPaths>>;
                  videoErrors: optional<Array$<typeof String$>>;
                  error: optional<typeof String$>;
                  timestamp: filter<Schema<number, number, never>>;
              } & newFields,
              Encoded<
                  {
                      url: typeof String$;
                      route: typeof String$;
                      state: optional<typeof String$>;
                      stateStatus: optional<Literal<["captured", "skipped", "failed"]>>;
                      failedStepIndex: optional<filter<Schema<number, number, never>>>;
                      screenshots: Record$<typeof String$, typeof ScreenshotPaths>;
                      videos: optional<Record$<typeof String$, typeof VideoQualityPaths>>;
                      videoErrors: optional<Array$<typeof String$>>;
                      error: optional<typeof String$>;
                      timestamp: filter<Schema<number, number, never>>;
                  },
              >,
              R2
              | R3
              | Context<newFields[keyof newFields]>,
              { state?: string } & { url: string } & { route: string } & {
                  stateStatus?: "captured" | "skipped" | "failed";
              } & { failedStepIndex?: number } & {
                  screenshots: { readonly [key: string]: ScreenshotPaths };
              } & { videos?: { readonly [key: string]: VideoQualityPaths } } & {
                  videoErrors?: readonly string[];
              } & { error?: string } & { timestamp: number } & Constructor<newFields>,
              CaptureResult,
              {},
          >

    • Type Parameters

      • Transformed = never

      Parameters

      • identifier: string

      Returns <newFields extends Fields, R2, R3>(
          fields: newFields,
          options: {
              decode: (
                  input: {
                      url: string;
                      route: string;
                      screenshots: {
                          readonly [key: string]: { png: string; webp: string; jpg: string };
                      };
                      timestamp: number;
                      state?: string;
                      stateStatus?: "captured"
                      | "skipped"
                      | "failed";
                      failedStepIndex?: number;
                      videos?: {
                          readonly [key: string]: {
                              high: string;
                              medium: string;
                              low: string;
                          };
                      };
                      videoErrors?: readonly string[];
                      error?: string;
                  },
                  options: ParseOptions,
                  ast: Transformation,
              ) => Effect<
                  {
                      [K in string
                      | number
                      | symbol]: (
                          {
                              url: string;
                              route: string;
                              screenshots: {
                                  readonly [key: string]: { png: string; webp: string; jpg: string };
                              };
                              timestamp: number;
                          } & {
                              state?: string;
                              stateStatus?: "captured"
                              | "skipped"
                              | "failed";
                              failedStepIndex?: number;
                              videos?: {
                                  readonly [key: string]: { high: ...; medium: ...; low: ... };
                              };
                              videoErrors?: readonly string[];
                              error?: string;
                          } & {
                              readonly [K in string
                              | number
                              | symbol as Key<newFields, K>]: Encoded<newFields[K]>
                          } & {
                              readonly [K in string
                              | number
                              | symbol as Key<newFields, K>]?: Encoded<(...)[(...)]>
                          }
                      )[K]
                  },
                  ParseIssue,
                  R2,
              >;
              encode: (
                  input: {
                      [K in string | number | symbol]: (
                          {
                              url: string;
                              route: string;
                              screenshots: {
                                  readonly [key: string]: { png: string; webp: string; jpg: string };
                              };
                              timestamp: number;
                          } & {
                              state?: string;
                              stateStatus?: "captured"
                              | "skipped"
                              | "failed";
                              failedStepIndex?: number;
                              videos?: {
                                  readonly [key: string]: {
                                      high: string;
                                      medium: string;
                                      low: string;
                                  };
                              };
                              videoErrors?: readonly string[];
                              error?: string;
                          } & {
                              readonly [K in string
                              | number
                              | symbol as Key<newFields, K>]: Encoded<newFields[K]>
                          } & {
                              readonly [K in string
                              | number
                              | symbol as Key<newFields, K>]?: Encoded<newFields[K]>
                          }
                      )[K]
                  },
                  options: ParseOptions,
                  ast: Transformation,
              ) => Effect<
                  Encoded<
                      {
                          url: typeof String$;
                          route: typeof String$;
                          state: optional<typeof String$>;
                          stateStatus: optional<Literal<["captured", "skipped", "failed"]>>;
                          failedStepIndex: optional<filter<Schema<number, number, never>>>;
                          screenshots: Record$<typeof String$, typeof ScreenshotPaths>;
                          videos: optional<Record$<typeof String$, typeof VideoQualityPaths>>;
                          videoErrors: optional<Array$<typeof String$>>;
                          error: optional<typeof String$>;
                          timestamp: 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,
              {
                  url: typeof String$;
                  route: typeof String$;
                  state: optional<typeof String$>;
                  stateStatus: optional<Literal<["captured", "skipped", "failed"]>>;
                  failedStepIndex: optional<filter<Schema<number, number, never>>>;
                  screenshots: Record$<typeof String$, typeof ScreenshotPaths>;
                  videos: optional<Record$<typeof String$, typeof VideoQualityPaths>>;
                  videoErrors: optional<Array$<typeof String$>>;
                  error: optional<typeof String$>;
                  timestamp: filter<Schema<number, number, never>>;
              } & newFields,
              Encoded<
                  {
                      url: typeof String$;
                      route: typeof String$;
                      state: optional<typeof String$>;
                      stateStatus: optional<Literal<["captured", "skipped", "failed"]>>;
                      failedStepIndex: optional<filter<Schema<number, number, never>>>;
                      screenshots: Record$<typeof String$, typeof ScreenshotPaths>;
                      videos: optional<Record$<typeof String$, typeof VideoQualityPaths>>;
                      videoErrors: optional<Array$<typeof String$>>;
                      error: optional<typeof String$>;
                      timestamp: filter<Schema<number, number, never>>;
                  },
              >,
              R2
              | R3
              | Context<newFields[keyof newFields]>,
              { state?: string } & { url: string } & { route: string } & {
                  stateStatus?: "captured" | "skipped" | "failed";
              } & { failedStepIndex?: number } & {
                  screenshots: { readonly [key: string]: ScreenshotPaths };
              } & { videos?: { readonly [key: string]: VideoQualityPaths } } & {
                  videoErrors?: readonly string[];
              } & { error?: string } & { timestamp: number } & Constructor<newFields>,
              CaptureResult,
              {},
          >

    • 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