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

    Class CaptureReport

    Hierarchy

    • { viewports: readonly ViewportConfig[] } & { timestamp: string } & {
          totalRoutes: number;
      } & { totalStates: number } & { successfulCaptures: number } & {
          failedCaptures: number;
      } & { skippedStates: number } & {
          results: readonly {
              url: string;
              route: string;
              state?: string;
              stateStatus?: "captured" | "skipped" | "failed";
              failedStepIndex?: number;
              screenshots: readonly string[];
              hasVideo: boolean;
              videoErrors?: readonly string[];
              error?: string;
          }[];
      } & Omit<
          {},
          | "viewports"
          | "timestamp"
          | "totalRoutes"
          | "totalStates"
          | "successfulCaptures"
          | "failedCaptures"
          | "skippedStates"
          | "results",
      >
      • CaptureReport
    Index
    constructor
    Type Encoded Context [TypeId] ast fields identifier timestamp totalRoutes totalStates successfulCaptures failedCaptures skippedStates viewports results
    make annotations extend transformOrFail transformOrFailFrom pipe

    • Parameters

      • props: {
            timestamp: string;
            totalRoutes: number;
            totalStates: number;
            successfulCaptures: number;
            failedCaptures: number;
            skippedStates: number;
            viewports: readonly ViewportConfig[];
            results: readonly {
                url: string;
                route: string;
                state?: string;
                stateStatus?: "captured" | "skipped" | "failed";
                failedStepIndex?: number;
                screenshots: readonly string[];
                hasVideo: boolean;
                videoErrors?: readonly string[];
                error?: string;
            }[];
        }
        • Readonlytimestamp: string
        • ReadonlytotalRoutes: number

          Crawled routes only; scripted states are counted separately.

        • ReadonlytotalStates: number
        • ReadonlysuccessfulCaptures: number
        • ReadonlyfailedCaptures: number
        • ReadonlyskippedStates: number

          States whose precondition was absent on the loaded page.

        • Readonlyviewports: readonly ViewportConfig[]
        • Readonlyresults: readonly {
              url: string;
              route: string;
              state?: string;
              stateStatus?: "captured" | "skipped" | "failed";
              failedStepIndex?: number;
              screenshots: readonly string[];
              hasVideo: boolean;
              videoErrors?: readonly string[];
              error?: string;
          }[]
      • Optionaloptions: MakeOptions

      Returns CaptureReport

    Type: CaptureReport
    Encoded: {
        viewports: readonly { name: string; width: number; height: number }[];
        timestamp: string;
        totalRoutes: number;
        totalStates: number;
        successfulCaptures: number;
        failedCaptures: number;
        skippedStates: number;
        results: readonly {
            url: string;
            route: string;
            screenshots: readonly string[];
            hasVideo: boolean;
            state?: string;
            stateStatus?: "captured" | "skipped" | "failed";
            failedStepIndex?: number;
            videoErrors?: readonly string[];
            error?: string;
        }[];
    }
    Context: never

    0.69.3

    "[TypeId]": {
        _A: Invariant<CaptureReport>;
        _I: Invariant<
            {
                viewports: readonly { name: string; width: number; height: number }[];
                timestamp: string;
                totalRoutes: number;
                totalStates: number;
                successfulCaptures: number;
                failedCaptures: number;
                skippedStates: number;
                results: readonly {
                    url: string;
                    route: string;
                    screenshots: readonly string[];
                    hasVideo: boolean;
                    state?: string;
                    stateStatus?: "captured" | "skipped" | "failed";
                    failedStepIndex?: number;
                    videoErrors?: readonly string[];
                    error?: string;
                }[];
            },
        >;
        _R: Covariant<never>;
    }
    ast: Transformation

    0.69.3

    fields: {
        timestamp: typeof String$;
        totalRoutes: filter<Schema<number, number, never>>;
        totalStates: filter<Schema<number, number, never>>;
        successfulCaptures: filter<Schema<number, number, never>>;
        failedCaptures: filter<Schema<number, number, never>>;
        skippedStates: filter<Schema<number, number, never>>;
        viewports: Array$<typeof ViewportConfig>;
        results: Array$<
            Struct<
                {
                    url: typeof String$;
                    route: typeof String$;
                    state: optional<typeof String$>;
                    stateStatus: optional<Literal<["captured", "skipped", "failed"]>>;
                    failedStepIndex: optional<filter<Schema<number, number, never>>>;
                    screenshots: Array$<typeof String$>;
                    hasVideo: typeof Boolean$;
                    videoErrors: optional<Array$<typeof String$>>;
                    error: optional<typeof String$>;
                },
            >,
        >;
    }

    Type Declaration

    • Readonlytimestamp: typeof String$
    • ReadonlytotalRoutes: filter<Schema<number, number, never>>

      Crawled routes only; scripted states are counted separately.

    • ReadonlytotalStates: filter<Schema<number, number, never>>
    • ReadonlysuccessfulCaptures: filter<Schema<number, number, never>>
    • ReadonlyfailedCaptures: filter<Schema<number, number, never>>
    • ReadonlyskippedStates: filter<Schema<number, number, never>>

      States whose precondition was absent on the loaded page.

    • Readonlyviewports: Array$<typeof ViewportConfig>
    • Readonlyresults: Array$<
          Struct<
              {
                  url: typeof String$;
                  route: typeof String$;
                  state: optional<typeof String$>;
                  stateStatus: optional<Literal<["captured", "skipped", "failed"]>>;
                  failedStepIndex: optional<filter<Schema<number, number, never>>>;
                  screenshots: Array$<typeof String$>;
                  hasVideo: typeof Boolean$;
                  videoErrors: optional<Array$<typeof String$>>;
                  error: optional<typeof String$>;
              },
          >,
      >
    identifier: string
    timestamp: string = S.String
    totalRoutes: number = ...

    Crawled routes only; scripted states are counted separately.

    totalStates: number = ...
    successfulCaptures: number = ...
    failedCaptures: number = ...
    skippedStates: number = ...

    States whose precondition was absent on the loaded page.

    viewports: readonly ViewportConfig[] = ...
    results: readonly {
        url: string;
        route: string;
        state?: string;
        stateStatus?: "captured" | "skipped" | "failed";
        failedStepIndex?: number;
        screenshots: readonly string[];
        hasVideo: boolean;
        videoErrors?: readonly string[];
        error?: string;
    }[] = ...

    • 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<
          CaptureReport,
          {
              viewports: readonly { name: string; width: number; height: number }[];
              timestamp: string;
              totalRoutes: number;
              totalStates: number;
              successfulCaptures: number;
              failedCaptures: number;
              skippedStates: number;
              results: readonly {
                  url: string;
                  route: string;
                  screenshots: readonly string[];
                  hasVideo: boolean;
                  state?: string;
                  stateStatus?: "captured" | "skipped" | "failed";
                  failedStepIndex?: number;
                  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,
              {
                  timestamp: typeof String$;
                  totalRoutes: filter<Schema<number, number, never>>;
                  totalStates: filter<Schema<number, number, never>>;
                  successfulCaptures: filter<Schema<number, number, never>>;
                  failedCaptures: filter<Schema<number, number, never>>;
                  skippedStates: filter<Schema<number, number, never>>;
                  viewports: Array$<typeof ViewportConfig>;
                  results: Array$<
                      Struct<
                          {
                              url: typeof String$;
                              route: typeof String$;
                              state: optional<typeof String$>;
                              stateStatus: optional<Literal<[(...), (...), (...)]>>;
                              failedStepIndex: optional<filter<Schema<(...), (...), (...)>>>;
                              screenshots: Array$<typeof String$>;
                              hasVideo: typeof Boolean$;
                              videoErrors: optional<Array$<typeof String$>>;
                              error: optional<typeof String$>;
                          },
                      >,
                  >;
              } & newFields,
              {
                  viewports: readonly { name: string; width: number; height: number }[];
                  timestamp: string;
                  totalRoutes: number;
                  totalStates: number;
                  successfulCaptures: number;
                  failedCaptures: number;
                  skippedStates: number;
                  results: readonly {
                      url: string;
                      route: string;
                      screenshots: readonly string[];
                      hasVideo: boolean;
                      state?: string;
                      stateStatus?: "captured" | "skipped" | "failed";
                      failedStepIndex?: number;
                      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]>,
              { viewports: readonly ViewportConfig[] } & { timestamp: string } & {
                  totalRoutes: number;
              } & { totalStates: number } & { successfulCaptures: number } & {
                  failedCaptures: number;
              } & { skippedStates: number } & {
                  results: readonly {
                      url: string;
                      route: string;
                      state?: string;
                      stateStatus?: "captured" | "skipped" | "failed";
                      failedStepIndex?: number;
                      screenshots: readonly string[];
                      hasVideo: boolean;
                      videoErrors?: readonly string[];
                      error?: string;
                  }[];
              } & Constructor<newFields>,
              CaptureReport,
              {},
          >

    • Type Parameters

      • Transformed = never

      Parameters

      • identifier: string

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

    • Type Parameters

      • Transformed = never

      Parameters

      • identifier: string

      Returns <newFields extends Fields, R2, R3>(
          fields: newFields,
          options: {
              decode: (
                  input: {
                      viewports: readonly { name: string; width: number; height: number }[];
                      timestamp: string;
                      totalRoutes: number;
                      totalStates: number;
                      successfulCaptures: number;
                      failedCaptures: number;
                      skippedStates: number;
                      results: readonly {
                          url: string;
                          route: string;
                          screenshots: readonly string[];
                          hasVideo: boolean;
                          state?: string;
                          stateStatus?: "captured" | "skipped" | "failed";
                          failedStepIndex?: number;
                          videoErrors?: readonly string[];
                          error?: string;
                      }[];
                  },
                  options: ParseOptions,
                  ast: Transformation,
              ) => Effect<
                  {
                      [K in string
                      | number
                      | symbol]: (
                          {
                              viewports: readonly { name: string; width: number; height: number }[];
                              timestamp: string;
                              totalRoutes: number;
                              totalStates: number;
                              successfulCaptures: number;
                              failedCaptures: number;
                              skippedStates: number;
                              results: readonly {
                                  url: string;
                                  route: string;
                                  screenshots: readonly (...)[];
                                  hasVideo: boolean;
                                  state?: (...) | (...);
                                  stateStatus?: (...) | (...) | (...) | (...);
                                  failedStepIndex?: (...) | (...);
                                  videoErrors?: (...) | (...);
                                  error?: (...) | (...);
                              }[];
                          } & {} & {
                              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]: (
                          {
                              viewports: readonly { name: string; width: number; height: number }[];
                              timestamp: string;
                              totalRoutes: number;
                              totalStates: number;
                              successfulCaptures: number;
                              failedCaptures: number;
                              skippedStates: number;
                              results: readonly {
                                  url: string;
                                  route: string;
                                  screenshots: readonly string[];
                                  hasVideo: boolean;
                                  state?: string;
                                  stateStatus?: "captured" | "skipped" | "failed";
                                  failedStepIndex?: number;
                                  videoErrors?: readonly (...)[];
                                  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<
                      {
                          timestamp: typeof String$;
                          totalRoutes: filter<Schema<number, number, never>>;
                          totalStates: filter<Schema<number, number, never>>;
                          successfulCaptures: filter<Schema<number, number, never>>;
                          failedCaptures: filter<Schema<number, number, never>>;
                          skippedStates: filter<Schema<number, number, never>>;
                          viewports: Array$<typeof ViewportConfig>;
                          results: Array$<
                              Struct<
                                  {
                                      url: typeof String$;
                                      route: typeof String$;
                                      state: optional<typeof String$>;
                                      stateStatus: optional<Literal<(...)>>;
                                      failedStepIndex: optional<filter<(...)>>;
                                      screenshots: Array$<typeof String$>;
                                      hasVideo: typeof Boolean$;
                                      videoErrors: optional<Array$<(...)>>;
                                      error: optional<typeof String$>;
                                  },
                              >,
                          >;
                      },
                  >,
                  ParseIssue,
                  R3,
              >;
          },
          annotations?: Schema<Transformed, readonly []>,
      ) => [Transformed] extends [never]
          ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`"
          : Class<
              Transformed,
              {
                  timestamp: typeof String$;
                  totalRoutes: filter<Schema<number, number, never>>;
                  totalStates: filter<Schema<number, number, never>>;
                  successfulCaptures: filter<Schema<number, number, never>>;
                  failedCaptures: filter<Schema<number, number, never>>;
                  skippedStates: filter<Schema<number, number, never>>;
                  viewports: Array$<typeof ViewportConfig>;
                  results: Array$<
                      Struct<
                          {
                              url: typeof String$;
                              route: typeof String$;
                              state: optional<typeof String$>;
                              stateStatus: optional<Literal<[(...), (...), (...)]>>;
                              failedStepIndex: optional<filter<Schema<(...), (...), (...)>>>;
                              screenshots: Array$<typeof String$>;
                              hasVideo: typeof Boolean$;
                              videoErrors: optional<Array$<typeof String$>>;
                              error: optional<typeof String$>;
                          },
                      >,
                  >;
              } & newFields,
              Encoded<
                  {
                      timestamp: typeof String$;
                      totalRoutes: filter<Schema<number, number, never>>;
                      totalStates: filter<Schema<number, number, never>>;
                      successfulCaptures: filter<Schema<number, number, never>>;
                      failedCaptures: filter<Schema<number, number, never>>;
                      skippedStates: filter<Schema<number, number, never>>;
                      viewports: Array$<typeof ViewportConfig>;
                      results: Array$<
                          Struct<
                              {
                                  url: typeof String$;
                                  route: typeof String$;
                                  state: optional<typeof String$>;
                                  stateStatus: optional<Literal<[(...), (...), (...)]>>;
                                  failedStepIndex: optional<filter<Schema<(...), (...), (...)>>>;
                                  screenshots: Array$<typeof String$>;
                                  hasVideo: typeof Boolean$;
                                  videoErrors: optional<Array$<typeof String$>>;
                                  error: optional<typeof String$>;
                              },
                          >,
                      >;
                  },
              >,
              R2
              | R3
              | Context<newFields[keyof newFields]>,
              { viewports: readonly ViewportConfig[] } & { timestamp: string } & {
                  totalRoutes: number;
              } & { totalStates: number } & { successfulCaptures: number } & {
                  failedCaptures: number;
              } & { skippedStates: number } & {
                  results: readonly {
                      url: string;
                      route: string;
                      state?: string;
                      stateStatus?: "captured" | "skipped" | "failed";
                      failedStepIndex?: number;
                      screenshots: readonly string[];
                      hasVideo: boolean;
                      videoErrors?: readonly string[];
                      error?: string;
                  }[];
              } & Constructor<newFields>,
              CaptureReport,
              {},
          >

    • 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