effect-tea-persistent
    Preparing search index...

    Class Entities

    The service through which an operation sends messages to other entities, as its own entity. The runtime provides it to each run of an operation, filling in the request from that run: its entity, key and incarnation, with the name the operation gives (decisions 0047, 0060).

    Hierarchy

    • Shape<
          "@fgaudo/effect-tea-persistent/Entities",
          {
              create: <
                  T extends
                      Readonly<
                          {
                              flags: unknown;
                              inbound: unknown;
                              index: string;
                              internal: unknown;
                              key: string;
                              operation: Readonly<{ _tag: string }>;
                              parameter: object;
                              projection: unknown;
                              rejection: unknown;
                              sender: unknown;
                              services: unknown;
                              state: object;
                              topics?: Readonly<Record<string, Json>>;
                          },
                      >,
              >(
                  program: Receiver<T>,
                  id: string,
                  name: string,
                  ...flags: Flagged<T>,
              ) => Effect<Creation<T["rejection"]>>;
              send: <
                  T extends
                      Readonly<
                          {
                              flags: unknown;
                              inbound: unknown;
                              index: string;
                              internal: unknown;
                              key: string;
                              operation: Readonly<{ _tag: string }>;
                              parameter: object;
                              projection: unknown;
                              rejection: unknown;
                              sender: unknown;
                              services: unknown;
                              state: object;
                              topics?: Readonly<Record<string, Json>>;
                          },
                      >,
              >(
                  program: Receiver<T>,
                  id: string,
                  message: T["inbound"],
                  name: string,
              ) => Effect<Reply<T["rejection"]>>;
          },
          this,
      >
      • Entities
    Index
    constructor
    [iterator] [NodeInspectSymbol] context of pipe toJSON toString use useSync
    ~effect/Context/Service key Service [ignoreSymbol]? [typeSymbol]? [unifySymbol]? ~effect/Context/Service ~effect/Effect Identifier key Service

    • Parameters

      • _: never

      Returns Entities

    • Returns EffectIterator<
          Effect<
              {
                  create: <
                      T extends
                          Readonly<
                              {
                                  flags: unknown;
                                  inbound: unknown;
                                  index: string;
                                  internal: unknown;
                                  key: string;
                                  operation: Readonly<{ _tag: string }>;
                                  parameter: object;
                                  projection: unknown;
                                  rejection: unknown;
                                  sender: unknown;
                                  services: unknown;
                                  state: object;
                                  topics?: Readonly<Record<string, Json>>;
                              },
                          >,
                  >(
                      program: Receiver<T>,
                      id: string,
                      name: string,
                      ...flags: Flagged<T>,
                  ) => Effect<Creation<T["rejection"]>>;
                  send: <
                      T extends
                          Readonly<
                              {
                                  flags: unknown;
                                  inbound: unknown;
                                  index: string;
                                  internal: unknown;
                                  key: string;
                                  operation: Readonly<{ _tag: string }>;
                                  parameter: object;
                                  projection: unknown;
                                  rejection: unknown;
                                  sender: unknown;
                                  services: unknown;
                                  state: object;
                                  topics?: Readonly<Record<string, Json>>;
                              },
                          >,
                  >(
                      program: Receiver<T>,
                      id: string,
                      message: T["inbound"],
                      name: string,
                  ) => Effect<Reply<T["rejection"]>>;
              },
              never,
              Entities,
          >,
      >

    • Returns unknown

    • Parameters

      • self: {
            create: <
                T extends
                    Readonly<
                        {
                            flags: unknown;
                            inbound: unknown;
                            index: string;
                            internal: unknown;
                            key: string;
                            operation: Readonly<{ _tag: string }>;
                            parameter: object;
                            projection: unknown;
                            rejection: unknown;
                            sender: unknown;
                            services: unknown;
                            state: object;
                            topics?: Readonly<Record<string, Json>>;
                        },
                    >,
            >(
                program: Receiver<T>,
                id: string,
                name: string,
                ...flags: Flagged<T>,
            ) => Effect<Creation<T["rejection"]>>;
            send: <
                T extends
                    Readonly<
                        {
                            flags: unknown;
                            inbound: unknown;
                            index: string;
                            internal: unknown;
                            key: string;
                            operation: Readonly<{ _tag: string }>;
                            parameter: object;
                            projection: unknown;
                            rejection: unknown;
                            sender: unknown;
                            services: unknown;
                            state: object;
                            topics?: Readonly<Record<string, Json>>;
                        },
                    >,
            >(
                program: Receiver<T>,
                id: string,
                message: T["inbound"],
                name: string,
            ) => Effect<Reply<T["rejection"]>>;
        }
        • Readonlycreate: <
              T extends
                  Readonly<
                      {
                          flags: unknown;
                          inbound: unknown;
                          index: string;
                          internal: unknown;
                          key: string;
                          operation: Readonly<{ _tag: string }>;
                          parameter: object;
                          projection: unknown;
                          rejection: unknown;
                          sender: unknown;
                          services: unknown;
                          state: object;
                          topics?: Readonly<Record<string, Json>>;
                      },
                  >,
          >(
              program: Receiver<T>,
              id: string,
              name: string,
              ...flags: Flagged<T>,
          ) => Effect<Creation<T["rejection"]>>

          Creates another entity, as create does.

        • Readonlysend: <
              T extends
                  Readonly<
                      {
                          flags: unknown;
                          inbound: unknown;
                          index: string;
                          internal: unknown;
                          key: string;
                          operation: Readonly<{ _tag: string }>;
                          parameter: object;
                          projection: unknown;
                          rejection: unknown;
                          sender: unknown;
                          services: unknown;
                          state: object;
                          topics?: Readonly<Record<string, Json>>;
                      },
                  >,
          >(
              program: Receiver<T>,
              id: string,
              message: T["inbound"],
              name: string,
          ) => Effect<Reply<T["rejection"]>>

          Sends an inbound message to another entity, as send does.

      Returns Context<Entities>

    • Parameters

      • this: void
      • self: {
            create: <
                T extends
                    Readonly<
                        {
                            flags: unknown;
                            inbound: unknown;
                            index: string;
                            internal: unknown;
                            key: string;
                            operation: Readonly<{ _tag: string }>;
                            parameter: object;
                            projection: unknown;
                            rejection: unknown;
                            sender: unknown;
                            services: unknown;
                            state: object;
                            topics?: Readonly<Record<string, Json>>;
                        },
                    >,
            >(
                program: Receiver<T>,
                id: string,
                name: string,
                ...flags: Flagged<T>,
            ) => Effect<Creation<T["rejection"]>>;
            send: <
                T extends
                    Readonly<
                        {
                            flags: unknown;
                            inbound: unknown;
                            index: string;
                            internal: unknown;
                            key: string;
                            operation: Readonly<{ _tag: string }>;
                            parameter: object;
                            projection: unknown;
                            rejection: unknown;
                            sender: unknown;
                            services: unknown;
                            state: object;
                            topics?: Readonly<Record<string, Json>>;
                        },
                    >,
            >(
                program: Receiver<T>,
                id: string,
                message: T["inbound"],
                name: string,
            ) => Effect<Reply<T["rejection"]>>;
        }
        • Readonlycreate: <
              T extends
                  Readonly<
                      {
                          flags: unknown;
                          inbound: unknown;
                          index: string;
                          internal: unknown;
                          key: string;
                          operation: Readonly<{ _tag: string }>;
                          parameter: object;
                          projection: unknown;
                          rejection: unknown;
                          sender: unknown;
                          services: unknown;
                          state: object;
                          topics?: Readonly<Record<string, Json>>;
                      },
                  >,
          >(
              program: Receiver<T>,
              id: string,
              name: string,
              ...flags: Flagged<T>,
          ) => Effect<Creation<T["rejection"]>>

          Creates another entity, as create does.

        • Readonlysend: <
              T extends
                  Readonly<
                      {
                          flags: unknown;
                          inbound: unknown;
                          index: string;
                          internal: unknown;
                          key: string;
                          operation: Readonly<{ _tag: string }>;
                          parameter: object;
                          projection: unknown;
                          rejection: unknown;
                          sender: unknown;
                          services: unknown;
                          state: object;
                          topics?: Readonly<Record<string, Json>>;
                      },
                  >,
          >(
              program: Receiver<T>,
              id: string,
              message: T["inbound"],
              name: string,
          ) => Effect<Reply<T["rejection"]>>

          Sends an inbound message to another entity, as send does.

      Returns {
          create: <
              T extends
                  Readonly<
                      {
                          flags: unknown;
                          inbound: unknown;
                          index: string;
                          internal: unknown;
                          key: string;
                          operation: Readonly<{ _tag: string }>;
                          parameter: object;
                          projection: unknown;
                          rejection: unknown;
                          sender: unknown;
                          services: unknown;
                          state: object;
                          topics?: Readonly<Record<string, Json>>;
                      },
                  >,
          >(
              program: Receiver<T>,
              id: string,
              name: string,
              ...flags: Flagged<T>,
          ) => Effect<Creation<T["rejection"]>>;
          send: <
              T extends
                  Readonly<
                      {
                          flags: unknown;
                          inbound: unknown;
                          index: string;
                          internal: unknown;
                          key: string;
                          operation: Readonly<{ _tag: string }>;
                          parameter: object;
                          projection: unknown;
                          rejection: unknown;
                          sender: unknown;
                          services: unknown;
                          state: object;
                          topics?: Readonly<Record<string, Json>>;
                      },
                  >,
          >(
              program: Receiver<T>,
              id: string,
              message: T["inbound"],
              name: string,
          ) => Effect<Reply<T["rejection"]>>;
      }

      • Readonlycreate: <
            T extends
                Readonly<
                    {
                        flags: unknown;
                        inbound: unknown;
                        index: string;
                        internal: unknown;
                        key: string;
                        operation: Readonly<{ _tag: string }>;
                        parameter: object;
                        projection: unknown;
                        rejection: unknown;
                        sender: unknown;
                        services: unknown;
                        state: object;
                        topics?: Readonly<Record<string, Json>>;
                    },
                >,
        >(
            program: Receiver<T>,
            id: string,
            name: string,
            ...flags: Flagged<T>,
        ) => Effect<Creation<T["rejection"]>>

        Creates another entity, as create does.

      • Readonlysend: <
            T extends
                Readonly<
                    {
                        flags: unknown;
                        inbound: unknown;
                        index: string;
                        internal: unknown;
                        key: string;
                        operation: Readonly<{ _tag: string }>;
                        parameter: object;
                        projection: unknown;
                        rejection: unknown;
                        sender: unknown;
                        services: unknown;
                        state: object;
                        topics?: Readonly<Record<string, Json>>;
                    },
                >,
        >(
            program: Receiver<T>,
            id: string,
            message: T["inbound"],
            name: string,
        ) => Effect<Reply<T["rejection"]>>

        Sends an inbound message to another entity, as send does.

    • 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

    • Returns unknown

    • Returns string

    • Type Parameters

      • A
      • E
      • R

      Parameters

      • f: (
            service: {
                create: <
                    T extends
                        Readonly<
                            {
                                flags: unknown;
                                inbound: unknown;
                                index: string;
                                internal: unknown;
                                key: string;
                                operation: Readonly<{ _tag: string }>;
                                parameter: object;
                                projection: unknown;
                                rejection: unknown;
                                sender: unknown;
                                services: unknown;
                                state: object;
                                topics?: Readonly<Record<string, Json>>;
                            },
                        >,
                >(
                    program: Receiver<T>,
                    id: string,
                    name: string,
                    ...flags: Flagged<T>,
                ) => Effect<Creation<T["rejection"]>>;
                send: <
                    T extends
                        Readonly<
                            {
                                flags: unknown;
                                inbound: unknown;
                                index: string;
                                internal: unknown;
                                key: string;
                                operation: Readonly<{ _tag: string }>;
                                parameter: object;
                                projection: unknown;
                                rejection: unknown;
                                sender: unknown;
                                services: unknown;
                                state: object;
                                topics?: Readonly<Record<string, Json>>;
                            },
                        >,
                >(
                    program: Receiver<T>,
                    id: string,
                    message: T["inbound"],
                    name: string,
                ) => Effect<Reply<T["rejection"]>>;
            },
        ) => Effect<A, E, R>

      Returns Effect<A, E, Entities | R>

    • Type Parameters

      • A

      Parameters

      • f: (
            service: {
                create: <
                    T extends
                        Readonly<
                            {
                                flags: unknown;
                                inbound: unknown;
                                index: string;
                                internal: unknown;
                                key: string;
                                operation: Readonly<{ _tag: string }>;
                                parameter: object;
                                projection: unknown;
                                rejection: unknown;
                                sender: unknown;
                                services: unknown;
                                state: object;
                                topics?: Readonly<Record<string, Json>>;
                            },
                        >,
                >(
                    program: Receiver<T>,
                    id: string,
                    name: string,
                    ...flags: Flagged<T>,
                ) => Effect<Creation<T["rejection"]>>;
                send: <
                    T extends
                        Readonly<
                            {
                                flags: unknown;
                                inbound: unknown;
                                index: string;
                                internal: unknown;
                                key: string;
                                operation: Readonly<{ _tag: string }>;
                                parameter: object;
                                projection: unknown;
                                rejection: unknown;
                                sender: unknown;
                                services: unknown;
                                state: object;
                                topics?: Readonly<Record<string, Json>>;
                            },
                        >,
                >(
                    program: Receiver<T>,
                    id: string,
                    message: T["inbound"],
                    name: string,
                ) => Effect<Reply<T["rejection"]>>;
            },
        ) => A

      Returns Effect<A, never, Entities>

    "~effect/Context/Service": "~effect/Context/Service"
    key: "@fgaudo/effect-tea-persistent/Entities"
    Service: {
        create: <
            T extends
                Readonly<
                    {
                        flags: unknown;
                        inbound: unknown;
                        index: string;
                        internal: unknown;
                        key: string;
                        operation: Readonly<{ _tag: string }>;
                        parameter: object;
                        projection: unknown;
                        rejection: unknown;
                        sender: unknown;
                        services: unknown;
                        state: object;
                        topics?: Readonly<Record<string, Json>>;
                    },
                >,
        >(
            program: Receiver<T>,
            id: string,
            name: string,
            ...flags: Flagged<T>,
        ) => Effect<Creation<T["rejection"]>>;
        send: <
            T extends
                Readonly<
                    {
                        flags: unknown;
                        inbound: unknown;
                        index: string;
                        internal: unknown;
                        key: string;
                        operation: Readonly<{ _tag: string }>;
                        parameter: object;
                        projection: unknown;
                        rejection: unknown;
                        sender: unknown;
                        services: unknown;
                        state: object;
                        topics?: Readonly<Record<string, Json>>;
                    },
                >,
        >(
            program: Receiver<T>,
            id: string,
            message: T["inbound"],
            name: string,
        ) => Effect<Reply<T["rejection"]>>;
    }

    Type Declaration

    • Readonlycreate: <
          T extends
              Readonly<
                  {
                      flags: unknown;
                      inbound: unknown;
                      index: string;
                      internal: unknown;
                      key: string;
                      operation: Readonly<{ _tag: string }>;
                      parameter: object;
                      projection: unknown;
                      rejection: unknown;
                      sender: unknown;
                      services: unknown;
                      state: object;
                      topics?: Readonly<Record<string, Json>>;
                  },
              >,
      >(
          program: Receiver<T>,
          id: string,
          name: string,
          ...flags: Flagged<T>,
      ) => Effect<Creation<T["rejection"]>>

      Creates another entity, as create does.

    • Readonlysend: <
          T extends
              Readonly<
                  {
                      flags: unknown;
                      inbound: unknown;
                      index: string;
                      internal: unknown;
                      key: string;
                      operation: Readonly<{ _tag: string }>;
                      parameter: object;
                      projection: unknown;
                      rejection: unknown;
                      sender: unknown;
                      services: unknown;
                      state: object;
                      topics?: Readonly<Record<string, Json>>;
                  },
              >,
      >(
          program: Receiver<T>,
          id: string,
          message: T["inbound"],
          name: string,
      ) => Effect<Reply<T["rejection"]>>

      Sends an inbound message to another entity, as send does.

    "[ignoreSymbol]"?: {}
    "[typeSymbol]"?: unknown
    "[unifySymbol]"?: EffectUnify<
        ServiceClass<
            Entities,
            "@fgaudo/effect-tea-persistent/Entities",
            {
                create: <
                    T extends
                        Readonly<
                            {
                                flags: unknown;
                                inbound: unknown;
                                index: string;
                                internal: unknown;
                                key: string;
                                operation: Readonly<{ _tag: string }>;
                                parameter: object;
                                projection: unknown;
                                rejection: unknown;
                                sender: unknown;
                                services: unknown;
                                state: object;
                                topics?: Readonly<Record<string, Json>>;
                            },
                        >,
                >(
                    program: Receiver<T>,
                    id: string,
                    name: string,
                    ...flags: Flagged<T>,
                ) => Effect<Creation<T["rejection"]>>;
                send: <
                    T extends
                        Readonly<
                            {
                                flags: unknown;
                                inbound: unknown;
                                index: string;
                                internal: unknown;
                                key: string;
                                operation: Readonly<{ _tag: string }>;
                                parameter: object;
                                projection: unknown;
                                rejection: unknown;
                                sender: unknown;
                                services: unknown;
                                state: object;
                                topics?: Readonly<Record<string, Json>>;
                            },
                        >,
                >(
                    program: Receiver<T>,
                    id: string,
                    message: T["inbound"],
                    name: string,
                ) => Effect<Reply<T["rejection"]>>;
            },
        >,
    >
    "~effect/Context/Service": "~effect/Context/Service"
    "~effect/Effect": Variance<
        {
            create: <
                T extends
                    Readonly<
                        {
                            flags: unknown;
                            inbound: unknown;
                            index: string;
                            internal: unknown;
                            key: string;
                            operation: Readonly<{ _tag: string }>;
                            parameter: object;
                            projection: unknown;
                            rejection: unknown;
                            sender: unknown;
                            services: unknown;
                            state: object;
                            topics?: Readonly<Record<string, Json>>;
                        },
                    >,
            >(
                program: Receiver<T>,
                id: string,
                name: string,
                ...flags: Flagged<T>,
            ) => Effect<Creation<T["rejection"]>>;
            send: <
                T extends
                    Readonly<
                        {
                            flags: unknown;
                            inbound: unknown;
                            index: string;
                            internal: unknown;
                            key: string;
                            operation: Readonly<{ _tag: string }>;
                            parameter: object;
                            projection: unknown;
                            rejection: unknown;
                            sender: unknown;
                            services: unknown;
                            state: object;
                            topics?: Readonly<Record<string, Json>>;
                        },
                    >,
            >(
                program: Receiver<T>,
                id: string,
                message: T["inbound"],
                name: string,
            ) => Effect<Reply<T["rejection"]>>;
        },
        never,
        Entities,
    >
    Identifier: Entities
    key: "@fgaudo/effect-tea-persistent/Entities"
    Service: {
        create: <
            T extends
                Readonly<
                    {
                        flags: unknown;
                        inbound: unknown;
                        index: string;
                        internal: unknown;
                        key: string;
                        operation: Readonly<{ _tag: string }>;
                        parameter: object;
                        projection: unknown;
                        rejection: unknown;
                        sender: unknown;
                        services: unknown;
                        state: object;
                        topics?: Readonly<Record<string, Json>>;
                    },
                >,
        >(
            program: Receiver<T>,
            id: string,
            name: string,
            ...flags: Flagged<T>,
        ) => Effect<Creation<T["rejection"]>>;
        send: <
            T extends
                Readonly<
                    {
                        flags: unknown;
                        inbound: unknown;
                        index: string;
                        internal: unknown;
                        key: string;
                        operation: Readonly<{ _tag: string }>;
                        parameter: object;
                        projection: unknown;
                        rejection: unknown;
                        sender: unknown;
                        services: unknown;
                        state: object;
                        topics?: Readonly<Record<string, Json>>;
                    },
                >,
        >(
            program: Receiver<T>,
            id: string,
            message: T["inbound"],
            name: string,
        ) => Effect<Reply<T["rejection"]>>;
    }

    Type Declaration

    • Readonlycreate: <
          T extends
              Readonly<
                  {
                      flags: unknown;
                      inbound: unknown;
                      index: string;
                      internal: unknown;
                      key: string;
                      operation: Readonly<{ _tag: string }>;
                      parameter: object;
                      projection: unknown;
                      rejection: unknown;
                      sender: unknown;
                      services: unknown;
                      state: object;
                      topics?: Readonly<Record<string, Json>>;
                  },
              >,
      >(
          program: Receiver<T>,
          id: string,
          name: string,
          ...flags: Flagged<T>,
      ) => Effect<Creation<T["rejection"]>>

      Creates another entity, as create does.

    • Readonlysend: <
          T extends
              Readonly<
                  {
                      flags: unknown;
                      inbound: unknown;
                      index: string;
                      internal: unknown;
                      key: string;
                      operation: Readonly<{ _tag: string }>;
                      parameter: object;
                      projection: unknown;
                      rejection: unknown;
                      sender: unknown;
                      services: unknown;
                      state: object;
                      topics?: Readonly<Record<string, Json>>;
                  },
              >,
      >(
          program: Receiver<T>,
          id: string,
          message: T["inbound"],
          name: string,
      ) => Effect<Reply<T["rejection"]>>

      Sends an inbound message to another entity, as send does.

    Settings
    Member Visibility

    On This Page
    Constructors
    Methods
    Properties