Class MessageType

Static Readonly[TypeId]

Static Readonlyast

Static ReadonlyContext

Static ReadonlyEncoded

Static ReadonlyType

Staticannotations

• annotations(
      annotations: GenericSchema<
          TypedObjectFields<
              {
                  blocks: mutable<
                      Array$<
                          Struct<
                              {
                                  content: optional<
                                      Ref$<TypedObjectFields<{ content: ... }, TypedObjectOptions>>,
                                  >;
                                  object: optional<Ref$<Expando>>;
                                  timestamp: typeof String$;
                              },
                          >,
                      >,
                  >;
                  context: optional<
                      Struct<
                          {
                              object: optional<typeof String$>;
                              schema: optional<typeof String$>;
                              space: optional<typeof String$>;
                          },
                      >,
                  >;
                  date: optional<typeof String$>;
                  links: optional<Array$<Ref$<Expando>>>;
                  read: optional<typeof Boolean$>;
                  subject: optional<typeof String$>;
                  type: optional<typeof String$>;
              },
              TypedObjectOptions,
          >,
      >,
  ): Schema<
      TypedObjectFields<
          {
              blocks: mutable<
                  Array$<
                      Struct<
                          {
                              content: optional<
                                  Ref$<TypedObjectFields<{ content: ... }, TypedObjectOptions>>,
                              >;
                              object: optional<Ref$<Expando>>;
                              timestamp: typeof String$;
                          },
                      >,
                  >,
              >;
              context: optional<
                  Struct<
                      {
                          object: optional<typeof String$>;
                          schema: optional<typeof String$>;
                          space: optional<typeof String$>;
                      },
                  >,
              >;
              date: optional<typeof String$>;
              links: optional<Array$<Ref$<Expando>>>;
              read: optional<typeof Boolean$>;
              subject: optional<typeof String$>;
              type: optional<typeof String$>;
          },
          TypedObjectOptions,
      >,
      Encoded<
          {
              blocks: mutable<
                  Array$<
                      Struct<
                          {
                              content: optional<
                                  Ref$<TypedObjectFields<{ content: ... }, TypedObjectOptions>>,
                              >;
                              object: optional<Ref$<Expando>>;
                              timestamp: typeof String$;
                          },
                      >,
                  >,
              >;
              context: optional<
                  Struct<
                      {
                          object: optional<typeof String$>;
                          schema: optional<typeof String$>;
                          space: optional<typeof String$>;
                      },
                  >,
              >;
              date: optional<typeof String$>;
              links: optional<Array$<Ref$<Expando>>>;
              read: optional<typeof Boolean$>;
              subject: optional<typeof String$>;
              type: optional<typeof String$>;
          },
      >,
      never,
  >

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

  Parameters

  • annotations: GenericSchema<
        TypedObjectFields<
            {
                blocks: mutable<
                    Array$<
                        Struct<
                            {
                                content: optional<
                                    Ref$<TypedObjectFields<{ content: ... }, TypedObjectOptions>>,
                                >;
                                object: optional<Ref$<Expando>>;
                                timestamp: typeof String$;
                            },
                        >,
                    >,
                >;
                context: optional<
                    Struct<
                        {
                            object: optional<typeof String$>;
                            schema: optional<typeof String$>;
                            space: optional<typeof String$>;
                        },
                    >,
                >;
                date: optional<typeof String$>;
                links: optional<Array$<Ref$<Expando>>>;
                read: optional<typeof Boolean$>;
                subject: optional<typeof String$>;
                type: optional<typeof String$>;
            },
            TypedObjectOptions,
        >,
    >

  Returns Schema<
      TypedObjectFields<
          {
              blocks: mutable<
                  Array$<
                      Struct<
                          {
                              content: optional<
                                  Ref$<TypedObjectFields<{ content: ... }, TypedObjectOptions>>,
                              >;
                              object: optional<Ref$<Expando>>;
                              timestamp: typeof String$;
                          },
                      >,
                  >,
              >;
              context: optional<
                  Struct<
                      {
                          object: optional<typeof String$>;
                          schema: optional<typeof String$>;
                          space: optional<typeof String$>;
                      },
                  >,
              >;
              date: optional<typeof String$>;
              links: optional<Array$<Ref$<Expando>>>;
              read: optional<typeof Boolean$>;
              subject: optional<typeof String$>;
              type: optional<typeof String$>;
          },
          TypedObjectOptions,
      >,
      Encoded<
          {
              blocks: mutable<
                  Array$<
                      Struct<
                          {
                              content: optional<
                                  Ref$<TypedObjectFields<{ content: ... }, TypedObjectOptions>>,
                              >;
                              object: optional<Ref$<Expando>>;
                              timestamp: typeof String$;
                          },
                      >,
                  >,
              >;
              context: optional<
                  Struct<
                      {
                          object: optional<typeof String$>;
                          schema: optional<typeof String$>;
                          space: optional<typeof String$>;
                      },
                  >,
              >;
              date: optional<typeof String$>;
              links: optional<Array$<Ref$<Expando>>>;
              read: optional<typeof Boolean$>;
              subject: optional<typeof String$>;
              type: optional<typeof String$>;
          },
      >,
      never,
  >

Staticpipe

• pipe<A>(this: A): A

  Type Parameters

  • A

  Parameters

  • this: A

  Returns A

• pipe<A, B = never>(this: A, ab: (_: A) => B): B

  Type Parameters

  • A
  • B = never

  Parameters

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

  Returns B

• pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C

  Type Parameters

  • A
  • B = never
  • C = never

  Parameters

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

  Returns C

• pipe<A, B = never, C = never, D = never>(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
  ): D

  Type Parameters

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

  Parameters

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

  Returns D

• pipe<A, B = never, C = never, D = never, E = never>(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
  ): E

  Type Parameters

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

  Parameters

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

  Returns E

• pipe<A, B = never, C = never, D = never, E = never, F = never>(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
  ): F

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F

  Returns F

• pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
  ): G

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G

  Returns G

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
  ): H

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H

  Returns H

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
  ): I

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I

  Returns I

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
  ): J

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J

  Returns J

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
  ): K

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K

  Returns K

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
  ): L

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L

  Returns L

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
      M = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
      lm: (_: L) => M,
  ): M

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never
  • M = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L
  • lm: (_: L) => M

  Returns M

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
      M = never,
      N = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
      lm: (_: L) => M,
      mn: (_: M) => N,
  ): N

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never
  • M = never
  • N = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L
  • lm: (_: L) => M
  • mn: (_: M) => N

  Returns N

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
      M = never,
      N = never,
      O = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
      lm: (_: L) => M,
      mn: (_: M) => N,
      no: (_: N) => O,
  ): O

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never
  • M = never
  • N = never
  • O = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L
  • lm: (_: L) => M
  • mn: (_: M) => N
  • no: (_: N) => O

  Returns O

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
      M = never,
      N = never,
      O = never,
      P = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
      lm: (_: L) => M,
      mn: (_: M) => N,
      no: (_: N) => O,
      op: (_: O) => P,
  ): P

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never
  • M = never
  • N = never
  • O = never
  • P = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L
  • lm: (_: L) => M
  • mn: (_: M) => N
  • no: (_: N) => O
  • op: (_: O) => P

  Returns P

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
      M = never,
      N = never,
      O = never,
      P = never,
      Q = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
      lm: (_: L) => M,
      mn: (_: M) => N,
      no: (_: N) => O,
      op: (_: O) => P,
      pq: (_: P) => Q,
  ): Q

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never
  • M = never
  • N = never
  • O = never
  • P = never
  • Q = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L
  • lm: (_: L) => M
  • mn: (_: M) => N
  • no: (_: N) => O
  • op: (_: O) => P
  • pq: (_: P) => Q

  Returns Q

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
      M = never,
      N = never,
      O = never,
      P = never,
      Q = never,
      R = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
      lm: (_: L) => M,
      mn: (_: M) => N,
      no: (_: N) => O,
      op: (_: O) => P,
      pq: (_: P) => Q,
      qr: (_: Q) => R,
  ): R

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never
  • M = never
  • N = never
  • O = never
  • P = never
  • Q = never
  • R = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L
  • lm: (_: L) => M
  • mn: (_: M) => N
  • no: (_: N) => O
  • op: (_: O) => P
  • pq: (_: P) => Q
  • qr: (_: Q) => R

  Returns R

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
      M = never,
      N = never,
      O = never,
      P = never,
      Q = never,
      R = never,
      S = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
      lm: (_: L) => M,
      mn: (_: M) => N,
      no: (_: N) => O,
      op: (_: O) => P,
      pq: (_: P) => Q,
      qr: (_: Q) => R,
      rs: (_: R) => S,
  ): S

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never
  • M = never
  • N = never
  • O = never
  • P = never
  • Q = never
  • R = never
  • S = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L
  • lm: (_: L) => M
  • mn: (_: M) => N
  • no: (_: N) => O
  • op: (_: O) => P
  • pq: (_: P) => Q
  • qr: (_: Q) => R
  • rs: (_: R) => S

  Returns S

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
      M = never,
      N = never,
      O = never,
      P = never,
      Q = never,
      R = never,
      S = never,
      T = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
      lm: (_: L) => M,
      mn: (_: M) => N,
      no: (_: N) => O,
      op: (_: O) => P,
      pq: (_: P) => Q,
      qr: (_: Q) => R,
      rs: (_: R) => S,
      st: (_: S) => T,
  ): T

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never
  • M = never
  • N = never
  • O = never
  • P = never
  • Q = never
  • R = never
  • S = never
  • T = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L
  • lm: (_: L) => M
  • mn: (_: M) => N
  • no: (_: N) => O
  • op: (_: O) => P
  • pq: (_: P) => Q
  • qr: (_: Q) => R
  • rs: (_: R) => S
  • st: (_: S) => T

  Returns T

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
      M = never,
      N = never,
      O = never,
      P = never,
      Q = never,
      R = never,
      S = never,
      T = never,
      U = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
      lm: (_: L) => M,
      mn: (_: M) => N,
      no: (_: N) => O,
      op: (_: O) => P,
      pq: (_: P) => Q,
      qr: (_: Q) => R,
      rs: (_: R) => S,
      st: (_: S) => T,
      tu: (_: T) => U,
  ): U

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never
  • M = never
  • N = never
  • O = never
  • P = never
  • Q = never
  • R = never
  • S = never
  • T = never
  • U = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L
  • lm: (_: L) => M
  • mn: (_: M) => N
  • no: (_: N) => O
  • op: (_: O) => P
  • pq: (_: P) => Q
  • qr: (_: Q) => R
  • rs: (_: R) => S
  • st: (_: S) => T
  • tu: (_: T) => U

  Returns U

• pipe<
      A,
      B = never,
      C = never,
      D = never,
      E = never,
      F = never,
      G = never,
      H = never,
      I = never,
      J = never,
      K = never,
      L = never,
      M = never,
      N = never,
      O = never,
      P = never,
      Q = never,
      R = never,
      S = never,
      T = never,
      U = never,
  >(
      this: A,
      ab: (_: A) => B,
      bc: (_: B) => C,
      cd: (_: C) => D,
      de: (_: D) => E,
      ef: (_: E) => F,
      fg: (_: F) => G,
      gh: (_: G) => H,
      hi: (_: H) => I,
      ij: (_: I) => J,
      jk: (_: J) => K,
      kl: (_: K) => L,
      lm: (_: L) => M,
      mn: (_: M) => N,
      no: (_: N) => O,
      op: (_: O) => P,
      pq: (_: P) => Q,
      qr: (_: Q) => R,
      rs: (_: R) => S,
      st: (_: S) => T,
      tu: (_: T) => U,
  ): U

  Type Parameters

  • A
  • B = never
  • C = never
  • D = never
  • E = never
  • F = never
  • G = never
  • H = never
  • I = never
  • J = never
  • K = never
  • L = never
  • M = never
  • N = never
  • O = never
  • P = never
  • Q = never
  • R = never
  • S = never
  • T = never
  • U = never

  Parameters

  • this: A
  • ab: (_: A) => B
  • bc: (_: B) => C
  • cd: (_: C) => D
  • de: (_: D) => E
  • ef: (_: E) => F
  • fg: (_: F) => G
  • gh: (_: G) => H
  • hi: (_: H) => I
  • ij: (_: I) => J
  • jk: (_: J) => K
  • kl: (_: K) => L
  • lm: (_: L) => M
  • mn: (_: M) => N
  • no: (_: N) => O
  • op: (_: O) => P
  • pq: (_: P) => Q
  • qr: (_: Q) => R
  • rs: (_: R) => S
  • st: (_: S) => T
  • tu: (_: T) => U

  Returns U