Entity

declare function fromRpcGroup<Type extends string, Rpcs extends Any>(
  type: Type,
  protocol: RpcGroup<Rpcs>,
): Entity<Type, Rpcs>;

declare function make<Type extends string, Rpcs extends readonly Array<Any>>(type: Type, protocol: Rpcs): Entity<Type, Rpcs[number]>

declare class CurrentAddress extends any {
  constructor();
}

declare class CurrentRunnerAddress extends any {
  constructor();
}

declare const keepAlive: (
  enabled: boolean,
) => Effect.Effect<void, never, Sharding | CurrentAddress>;

declare class KeepAliveLatch extends any {
  constructor();
}

declare const KeepAliveRpc: any;

type Any = Entity<string, Rpc.Any>;

interface Entity<in out Type extends string, in out Rpcs extends Rpc.Any> extends Equal {
  readonly [TypeId]: typeof TypeId;
  readonly client: Effect<
    (entityId: string) => From<Rpcs, PersistenceError | MailboxFull | AlreadyProcessingMessage>,
    never,
    Sharding
  >;
  readonly protocol: RpcGroup<Rpcs>;
  readonly type: Type & Brand<"EntityType">;
  annotate<I, S>(tag: Tag<I, S>, value: S): Entity<Type, Rpcs>;
  annotateContext<S>(context: Context<S>): Entity<Type, Rpcs>;
  annotateRpcs<I, S>(tag: Tag<I, S>, value: S): Entity<Type, Rpcs>;
  annotateRpcsContext<S>(context: Context<S>): Entity<Type, Rpcs>;
  getShardGroup(entityId: any): string;
  getShardId(entityId: any): Effect<ShardId, never, Sharding>;
  of<Handlers extends HandlersFrom<Rpcs>>(handlers: Handlers): Handlers;
  toLayer<Handlers extends HandlersFrom<Rpcs>, RX = never>(
    build: Handlers | Effect<Handlers, never, RX>,
    options?: {
      readonly concurrency?: number | "unbounded";
      readonly defectRetryPolicy?: Schedule<any, unknown, never, never>;
      readonly disableFatalDefects?: boolean;
      readonly mailboxCapacity?: number | "unbounded";
      readonly maxIdleTime?: any;
      readonly spanAttributes?: Record<string, string>;
    },
  ): Layer<never, never, any>;
  toLayerMailbox<R, RX = never>(
    build: (
      mailbox: ReadonlyMailbox<Request<Rpcs>>,
      replier: Replier<Rpcs>,
    ) =>
      | Effect<never, never, R>
      | Effect<
          (
            mailbox: ReadonlyMailbox<Request<Rpcs>>,
            replier: Replier<Rpcs>,
          ) => Effect<never, never, R>,
          never,
          RX
        >,
    options?: {
      readonly defectRetryPolicy?: Schedule<any, unknown, never, never>;
      readonly disableFatalDefects?: boolean;
      readonly mailboxCapacity?: number | "unbounded";
      readonly maxIdleTime?: any;
      readonly spanAttributes?: Record<string, string>;
    },
  ): Layer<never, never, any>;
}

type HandlersFrom<Rpc extends Rpc.Any> = {
  [Current in Rpc]: (
    envelope: Request<Current>,
  ) => Rpc.ResultFrom<Current, any> | Rpc.Wrapper<Rpc.ResultFrom<Current, any>>;
};

declare function isEntity(u: unknown): u is Any;

interface Replier<Rpcs extends Rpc.Any> {
  readonly complete: <R extends Any>(
    request: Request<R>,
    exit: Exit<any, Error<R>>,
  ) => Effect<void>;
  readonly fail: <R extends Any>(request: Request<R>, error: Error<R>) => Effect<void>;
  readonly failCause: <R extends Any>(request: Request<R>, cause: Cause<Error<R>>) => Effect<void>;
  readonly succeed: <R extends Any>(request: Request<R>, value: any) => Effect<void>;
}

declare class Request<Rpc extends Rpc.Any> extends Class<Envelope.Request<Rpc> & {
  readonly lastSentChunk: Option.Option<Reply.Chunk<Rpc>>;
}> {
  constructor<Rpc extends Any>(args: {
    readonly _tag: "Request";
    readonly [TypeId]: typeof TypeId;
    readonly address: EntityAddress;
    readonly headers: Headers;
    readonly lastSentChunk: Option<Chunk<Rpc>>;
    readonly payload: Payload<Rpc>;
    readonly requestId: Snowflake;
    readonly sampled?: boolean;
    readonly spanId?: string;
    readonly tag: Tag<Rpc>;
    readonly traceId?: string;
  });
  lastSentChunkValue: Option<SuccessChunk<Rpc>>;
  nextSequence: number;
}

declare const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE, LR>(
  entity: Entity<Type, Rpcs>,
  layer: Layer.Layer<LA, LE, LR>,
) => Effect.Effect<
  (entityId: string) => Effect.Effect<RpcClient.RpcClient<Rpcs>>,
  LE,
  Scope | ShardingConfig | Exclude<LR, Sharding> | Rpc.MiddlewareClient<Rpcs>
>;

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;