.opencode/node_modules/effect/dist/unstable/eventlog/EventLog.d.ts

/**
 * Runtime for writing typed events to an event journal.
 *
 * `EventLog` combines event groups, handlers, a journal, local identity,
 * optional remote replicas, and reactivity hooks. Writers send typed payloads
 * through a client; the matching handler runs first, and the journal entry is
 * committed only after the handler succeeds. This module also contains the
 * layers and helpers needed to assemble that runtime.
 *
 * @since 4.0.0
 */
import * as Context from "../../Context.ts";
import * as Effect from "../../Effect.ts";
import * as Layer from "../../Layer.ts";
import type { Pipeable } from "../../Pipeable.ts";
import type * as Record from "../../Record.ts";
import * as Redacted from "../../Redacted.ts";
import * as Schema from "../../Schema.ts";
import type * as Scope from "../../Scope.ts";
import type { Covariant } from "../../Types.ts";
import { Reactivity } from "../reactivity/Reactivity.ts";
import type * as Event from "./Event.ts";
import type * as EventGroup from "./EventGroup.ts";
import { Entry, EventJournal, type EventJournalError } from "./EventJournal.ts";
import * as EventLogEncryption from "./EventLogEncryption.ts";
import { StoreId } from "./EventLogMessage.ts";
import type { EventLogRemote } from "./EventLogRemote.ts";
declare const EventLog_base: Context.ServiceClass<EventLog, "effect/eventlog/EventLog", {
    readonly write: <Groups extends EventGroup.Any, Tag extends Event.Tag<EventGroup.Events<Groups>>>(options: {
        readonly schema: EventLogSchema<Groups>;
        readonly event: Tag;
        readonly payload: Event.PayloadWithTag<EventGroup.Events<Groups>, Tag>;
    }) => Effect.Effect<Event.SuccessWithTag<EventGroup.Events<Groups>, Tag>, Event.ErrorWithTag<EventGroup.Events<Groups>, Tag> | EventJournalError>;
    readonly entries: Effect.Effect<ReadonlyArray<Entry>, EventJournalError>;
    readonly destroy: Effect.Effect<void, EventJournalError>;
}>;
/**
 * Service for writing typed event-log events through registered handlers.
 *
 * **Details**
 *
 * `write` encodes the event payload, runs the matching handler, commits the entry
 * only when the handler succeeds, and exposes access to the underlying journal
 * entries and destroy operation.
 *
 * @category services
 * @since 4.0.0
 */
export declare class EventLog extends EventLog_base {
}
declare const Registry_base: Context.ServiceClass<Registry, "effect/unstable/eventlog/EventLog/Registry", {
    readonly registerHandlerUnsafe: (options: {
        readonly event: string;
        readonly handler: Handlers.Item<any>;
    }) => void;
    readonly handlers: ReadonlyMap<string, Handlers.Item<any>>;
    readonly registerCompaction: (options: {
        readonly events: ReadonlyArray<string>;
        readonly effect: (options: {
            readonly entries: ReadonlyArray<Entry>;
            readonly write: (entry: Entry) => Effect.Effect<void>;
        }) => Effect.Effect<void>;
    }) => Effect.Effect<void, never, Scope.Scope>;
    readonly compactors: ReadonlyMap<string, {
        readonly events: ReadonlySet<string>;
        readonly effect: (options: {
            readonly entries: ReadonlyArray<Entry>;
            readonly write: (entry: Entry) => Effect.Effect<void>;
        }) => Effect.Effect<void>;
    }>;
    readonly registerRemote: (remote: EventLogRemote["Service"]) => Effect.Effect<void, never, Scope.Scope>;
    readonly handleRemote: (handler: (remote: EventLogRemote["Service"]) => Effect.Effect<void>) => Effect.Effect<void>;
    readonly registerReactivity: (keys: Record<string, ReadonlyArray<string>>) => Effect.Effect<void, never, Scope.Scope>;
    readonly reactivityKeys: Record<string, ReadonlyArray<string>>;
}>;
/**
 * Service that collects event handlers, compaction handlers, remote replicas,
 * and reactivity invalidation keys.
 *
 * @category services
 * @since 4.0.0
 */
export declare class Registry extends Registry_base {
}
/**
 * Provides an in-memory `Registry` for event handlers, compactors, remote
 * replicas, and reactivity keys.
 *
 * @category layers
 * @since 4.0.0
 */
export declare const layerRegistry: Layer.Layer<Registry, never, never>;
declare const Identity_base: Context.ServiceClass<Identity, "effect/eventlog/EventLog/Identity", {
    readonly publicKey: string;
    readonly privateKey: Redacted.Redacted<Uint8Array<ArrayBuffer>>;
}>;
/**
 * Context service for an event-log identity containing a public key and redacted
 * private key material.
 *
 * **Details**
 *
 * The identity is used by remote replication for authentication and by the
 * encryption service to derive signing and encryption keys.
 *
 * @category services
 * @since 4.0.0
 */
export declare class Identity extends Identity_base {
}
/**
 * Type-level identifier used to brand `EventLogSchema` values.
 *
 * @category type IDs
 * @since 4.0.0
 */
export type SchemaTypeId = "~effect/eventlog/EventLog/Schema";
/**
 * Runtime property key used to identify `EventLogSchema` values.
 *
 * @category type IDs
 * @since 4.0.0
 */
export declare const SchemaTypeId: SchemaTypeId;
/**
 * Returns `true` when a value carries the `EventLogSchema` marker.
 *
 * @category schemas
 * @since 4.0.0
 */
export declare const isEventLogSchema: (u: unknown) => u is EventLogSchema<EventGroup.Any>;
/**
 * Schema describing the event groups that can be written through an `EventLog`.
 *
 * @category schemas
 * @since 4.0.0
 */
export interface EventLogSchema<Groups extends EventGroup.Any> {
    readonly [SchemaTypeId]: SchemaTypeId;
    readonly groups: ReadonlyArray<Groups>;
}
/**
 * Creates an `EventLogSchema` from one or more event groups.
 *
 * @category schemas
 * @since 4.0.0
 */
export declare const schema: <Groups extends ReadonlyArray<EventGroup.Any>>(...groups: Groups) => EventLogSchema<Groups[number]>;
/**
 * Type-level identifier used to brand `Handlers` values.
 *
 * @category type IDs
 * @since 4.0.0
 */
export type HandlersTypeId = "~effect/eventlog/EventLog/Handlers";
/**
 * Runtime property key used to identify `Handlers` values.
 *
 * @category type IDs
 * @since 4.0.0
 */
export declare const HandlersTypeId: HandlersTypeId;
/**
 * Builder for the handlers associated with an `EventGroup`.
 *
 * **Details**
 *
 * The `Events` type parameter tracks the event tags that still need handlers, and
 * each call to `handle` records a handler while accumulating any required
 * services.
 *
 * @category handlers
 * @since 4.0.0
 */
export interface Handlers<R, Events extends Event.Any = never> extends Pipeable {
    readonly [HandlersTypeId]: {
        _Events: Covariant<Events>;
    };
    readonly group: EventGroup.AnyWithProps;
    readonly handlers: Record.ReadonlyRecord<string, Handlers.Item<R>>;
    readonly context: Context.Context<R>;
    /**
     * Add the implementation for an `Event` to a `Handlers` group.
     */
    handle<Tag extends Event.Tag<Events>, R1>(name: Tag, handler: (options: {
        readonly storeId: StoreId;
        readonly payload: Event.PayloadWithTag<Events, Tag>;
        readonly entry: Entry;
        readonly conflicts: ReadonlyArray<{
            readonly entry: Entry;
            readonly payload: Event.PayloadWithTag<Events, Tag>;
        }>;
    }) => Effect.Effect<Event.SuccessWithTag<Events, Tag>, Event.ErrorWithTag<Events, Tag>, R1>): Handlers<R | R1, Event.ExcludeTag<Events, Tag>>;
}
/**
 * Namespace containing helper types for `Handlers` values and handler-producing
 * layers.
 *
 * @since 4.0.0
 */
export declare namespace Handlers {
    /**
     * Type that matches any `Handlers` value regardless of its services or remaining
     * events.
     *
     * @category handlers
     * @since 4.0.0
     */
    interface Any {
        readonly [HandlersTypeId]: unknown;
    }
    /**
     * Runtime representation of one registered event handler, including its event
     * metadata, captured context, and handler function.
     *
     * @category handlers
     * @since 4.0.0
     */
    type Item<R> = {
        readonly event: Event.AnyWithProps;
        readonly context: Context.Context<R>;
        readonly handler: (options: {
            readonly storeId: StoreId;
            readonly payload: unknown;
            readonly entry: Entry;
            readonly conflicts: ReadonlyArray<{
                readonly entry: Entry;
                readonly payload: unknown;
            }>;
        }) => Effect.Effect<unknown, unknown, R>;
    };
    /**
     * Validates that a handler builder returned all required handlers.
     *
     * **Details**
     *
     * If any event tag remains unhandled, the type evaluates to an explanatory
     * compile-time error string.
     *
     * @category handlers
     * @since 4.0.0
     */
    type ValidateReturn<A> = A extends (Handlers<infer _R, infer _Events> | Effect.Effect<Handlers<infer _R, infer _Events>, infer _EX, infer _RX>) ? [_Events] extends [never] ? A : `Event not handled: ${Event.Tag<_Events>}` : `Must return the implemented handlers`;
    /**
     * Extracts the error type from an effect that produces `Handlers`.
     *
     * @category handlers
     * @since 4.0.0
     */
    type Error<A> = A extends Effect.Effect<Handlers<infer _R, infer _Events>, infer _EX, infer _RX> ? _EX : never;
    /**
     * Computes the services required by a `Handlers` value or by an effect that
     * produces one, including event schema services.
     *
     * @category handlers
     * @since 4.0.0
     */
    type Services<A> = A extends Handlers<infer _R, infer _Events> ? _R | Event.Services<_Events> : A extends Effect.Effect<Handlers<infer _R, infer _Events>, infer _EX, infer _RX> ? _R | _RX | Event.Services<_Events> : never;
}
declare const CurrentStoreId_base: Context.Reference<StoreId>;
/**
 * Context reference for the store id used by event-log writes and remote
 * replication.
 *
 * **Details**
 *
 * Defaults to the branded store id `"default"`.
 *
 * @category models
 * @since 4.0.0
 */
export declare class CurrentStoreId extends CurrentStoreId_base {
}
/**
 * Schema for an event-log identity with a string public key and redacted
 * base64-encoded private key bytes.
 *
 * @category schemas
 * @since 4.0.0
 */
export declare const IdentitySchema: Schema.Struct<{
    readonly publicKey: Schema.String;
    readonly privateKey: Schema.decodeTo<Schema.Redacted<Schema.Uint8Array>, Schema.Uint8ArrayFromBase64, never, never>;
}>;
/**
 * Decodes a base64url identity string produced by `encodeIdentityString`.
 *
 * **Gotchas**
 *
 * Invalid input throws a schema decoding error.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const decodeIdentityString: (value: string) => Identity["Service"];
/**
 * Encodes an event-log identity as a base64url string containing the public key
 * and private key bytes.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const encodeIdentityString: (identity: Identity["Service"]) => string;
/**
 * Generates a new event-log identity using the configured
 * `EventLogEncryption` service.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const makeIdentity: Effect.Effect<Identity["Service"], never, EventLogEncryption.EventLogEncryption>;
/**
 * Creates a layer that registers handlers for every event in an event group.
 *
 * **Details**
 *
 * The callback receives a `Handlers` builder; its return type is checked so every
 * event in the group is handled.
 *
 * @category handlers
 * @since 4.0.0
 */
export declare const group: <Events extends Event.Any, Return>(group: EventGroup.EventGroup<Events>, f: (handlers: Handlers<never, Events>) => Handlers.ValidateReturn<Return>) => Layer.Layer<Event.ToService<Events>, Handlers.Error<Return>, Exclude<Handlers.Services<Return>, Scope.Scope | Identity> | Registry>;
/**
 * Registers a compaction handler for an event group.
 *
 * **Details**
 *
 * During remote replay, matching entries are decoded, grouped by primary key, and
 * passed to the compaction effect, which may write replacement entries.
 *
 * @category compaction
 * @since 4.0.0
 */
export declare const groupCompaction: <Events extends Event.Any, R>(group: EventGroup.EventGroup<Events>, effect: (options: {
    readonly primaryKey: string;
    readonly entries: ReadonlyArray<Entry>;
    readonly events: ReadonlyArray<Event.TaggedPayload<Events>>;
    readonly write: <Tag extends Event.Tag<Events>>(tag: Tag, payload: Event.PayloadWithTag<Events, Tag>) => Effect.Effect<void, never, Event.PayloadSchemaWithTag<Events, Tag>["EncodingServices"]>;
}) => Effect.Effect<void, never, R>) => Layer.Layer<never, never, R | Event.PayloadSchema<Events>["DecodingServices"] | Registry>;
/**
 * Registers reactivity keys to invalidate when events from a group are written or
 * replayed.
 *
 * **Details**
 *
 * Pass a single key list for all events or a mapping from event tag to key list.
 *
 * @category reactivity
 * @since 4.0.0
 */
export declare const groupReactivity: <Events extends Event.Any>(group: EventGroup.EventGroup<Events>, keys: { readonly [Tag in Event.Tag<Events>]?: ReadonlyArray<string>; } | ReadonlyArray<string>) => Layer.Layer<never, never, Registry>;
/**
 * Builds the effect used to replay entries received from a remote event log.
 *
 * **Details**
 *
 * The returned handler decodes the entry and conflicts with the registered event
 * schema, runs the matching handler with the supplied identity and store id, logs
 * failures, and invalidates configured reactivity keys.
 *
 * @category handlers
 * @since 4.0.0
 */
export declare const makeReplayFromRemote: (options: {
    readonly handlers: ReadonlyMap<string, Handlers.Item<any>>;
    readonly storeId: StoreId;
    readonly identity: Identity["Service"];
    readonly reactivity: Reactivity["Service"];
    readonly reactivityKeys: Record<string, ReadonlyArray<string>>;
    readonly logAnnotations: {
        readonly service: string;
        readonly effect: string;
    };
}) => (args_0: {
    readonly entry: Entry;
    readonly conflicts: ReadonlyArray<Entry>;
}) => Effect.Effect<void, never, never>;
/**
 * Provides `EventLog` and `Registry` using the configured `EventJournal` and
 * `Identity`.
 *
 * @category layers
 * @since 4.0.0
 */
export declare const layerEventLog: Layer.Layer<EventLog | Registry, never, EventJournal | Identity>;
/**
 * Combines event-group handler layers with the `EventLog` runtime for a schema.
 *
 * **When to use**
 *
 * Use when you need one layer that installs the shared `EventLog` runtime for
 * an `EventLogSchema` and registers an event-group handler layer for typed
 * writes.
 *
 * **Details**
 *
 * The supplied handler layer is provided with `layerEventLog`. The returned
 * layer provides `EventLog | Registry`, preserves the handler layer's error
 * type, and still requires its remaining services plus `EventJournal` and
 * `Identity`.
 *
 * **Gotchas**
 *
 * The schema argument does not register handlers by itself. Handler registration
 * comes from the supplied layer, and writing an event without a registered
 * handler dies with `Event handler not found for: "<tag>"`.
 *
 * @see {@link schema} for creating the schema argument from event groups
 * @see {@link group} for building the handler layer consumed by this layer
 * @see {@link layerEventLog} for installing the runtime and registry without combining a handler layer
 *
 * @category layers
 * @since 4.0.0
 */
export declare const layer: <Groups extends EventGroup.Any, E, R>(_schema: EventLogSchema<Groups>, layer: Layer.Layer<EventGroup.ToService<Groups>, E, R>) => Layer.Layer<EventLog | Registry, E, Exclude<R, EventLog | Registry> | EventJournal | Identity>;
/**
 * Creates a typed client function for writing events defined by an
 * `EventLogSchema`.
 *
 * **Details**
 *
 * The returned function delegates to the `EventLog` service and preserves each
 * event's success and error types.
 *
 * @category client
 * @since 4.0.0
 */
export declare const makeClient: <Groups extends EventGroup.Any>(schema: EventLogSchema<Groups>) => Effect.Effect<(<Tag extends Event.Tag<EventGroup.Events<Groups>>>(event: Tag, payload: Event.PayloadWithTag<EventGroup.Events<Groups>, Tag>) => Effect.Effect<Event.SuccessWithTag<EventGroup.Events<Groups>, Tag>, Event.ErrorWithTag<EventGroup.Events<Groups>, Tag> | EventJournalError>), never, EventLog>;
export {};
//# sourceMappingURL=EventLog.d.ts.map