(transport: ReadonlyDeep<Client.Transport>)

( streamId: string, eventNumber: number, type: string, data: unknown, timestamp: ReadonlyDeep<Date>

( effect: Effect.Effect<A, E2, FooEventStore> )

(target: string, name: string, payload: unknown)

(streamId: string, eventNumber: number)

( id: string, type: string, payload: string, metadata?: Readonly<Record<string, unknown>> )

(events: readonly FooEvent[], position: EventStreamPosition)

(count: number)

()

(eventStoreTag: Readonly<Context.Tag<EventStore<TEvent>, EventStore<TEvent>>>)

( server: ReadonlyDeep<InMemoryServer>, commandHandler: (cmd: ReadonlyDeep<WireCommand>) => CommandResult

(actual: A, expected: A, message?: string, ..._: Array<never>)

(event: unknown)

( store: EncodedStore, position: EventStreamPosition, events: readonly TodoEvent[] )

( overrides: { readonly [K in keyof Readonly<TodoState>]?: Readonly<TodoState>[K] } = {} )

( commandHandler: (cmd: ReadonlyDeep<WireCommand>) => CommandResult, testLogic: ( clientTransport: Rea

(subscription: Stream.Stream<{ readonly event: TodoEvent }>, count = 1)

(methodName, supportedTypes)

( handlers: ReadonlyMap<string, CommandHandler<TestEvent>> = new Map() )

( type: Schema.Schema<TType, R>, data: F )

(message: string)

(id: string)

(streamId: string)

()

()

( commandHandler: (cmd: ReadonlyDeep<WireCommand>) => CommandResult, subscriptionHandler: (streamId: strin

( stateRef: Readonly<Ref.Ref<WebSocketInternalState>>, newState: Readonly<ConnectionState> )

(config: TestSocketConfig = {})

( aggregateName: string )

( name: TName, payloadSchema: Schema.Schema<TPayload, TPayloadInput> )

(a: string, b: number)

()

( commands: ReadonlyDeep<T>, matcher: CommandMatcher<CommandFromDefinitions<T>> )

( mapEffect: <A, E>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, never> )

( testLogic: (env: { readonly server: ReadonlyDeep<InMemoryServer>; readonly clientTransport: Readon

( command: ReadonlyDeep<WireCommand>, clientTransport: ReadonlyDeep<Server.ClientConnection['transport']>

(expected: A)

(event: unknown)

(message: string)

( u: unknown )

(...segments: readonly string[])

( config: FileSystemStoreConfig )

(eventsByStreamId: Record<string, readonly Event[]>)

(streamId: Effect.Effect<EventStreamId, ParseResult.ParseError, never>)

( ctx: BunTestContext, args: TestArgs, self: Buntest.Buntest.TestFunction<A, E, R, TestArgs> )

(ctx?: BunTestContext)

(timeout?: number | { timeout?: number })

(x: number)

(baseDir: string)

(schema: Schema.Schema<A, I>)

(pkg: unknown, key: string)

(name, self, timeout)

( baseDir: string, streamId: EventStreamId, path: Path.Path )

(node)

(prefix: string)

(initiator: TInitiator)

( operation: string, onSome: (state: TodoState) => Effect.Effect<A, E, R> )

(server: ReadonlyDeep<InMemoryServer>, payload: string)

( clientState: ReadonlyDeep<ClientState>, newState: ReadonlyDeep<ConnectionState> )

()

(config: { readonly store: Context.Tag<unknown, EventStore<TEvent>>; })

(server: ReadonlyDeep<Server.Transport>)

(events: readonly FooEvent[], position: EventStreamPosition)

( store: EventStore<string>, streamId: EventStreamId, events: readonly string[] )

(params, args)

()

(dir: string)

()

( todoId: TodoId, command: ( state: Readonly<Option.Option<TodoState>> ) => Effect.Effect<ReadonlyAr

(operation: string)

()

()

(callee)

(msg: MessageType)

(client: ClientTransport)

(node)

(message: string, error: unknown)

( _idSchema: Schema.Schema<TId, string>, // eslint-disable-next-line @typescript-eslint/no-explicit-any --

( type: string, payload: TPayload, options?: { id?: string; metadata?: Record<string, unknown>;

()

( name: string, makeEventStore: () => Layer.Layer<FooEventStore, E, unknown>, options: EventStoreTestOpt

( storeName: string, makeStoreLayer: Layer.Layer<StringEventStore, E, never> )

(streamId: string, count: number, verify: (events: readonly Event[]) => void)

( streamId: Effect.Effect<EventStreamId, ParseResult.ParseError, never>, count: number, receivedEv

(url: string, updates: ConnectionStatusUpdate)

(commandId: string)

(position: EventStreamPosition, newEvents: Chunk.Chunk<V>)

(filter?: (message: ReadonlyDeep<TransportMessage>) => boolean)

(startTime: number)

(stream: Stream.Stream<T, unknown, never>, count: number)

( todoId: TodoId, eventNumber: number, events: Readonly<ReadonlyArray<TodoEvent>>, successMessage: str

(server: ServerTransport, pair: TransportPair)

( clientState: ReadonlyDeep<InMemoryClientState> )

()

()

()

()

(schema: Schema.Schema<A, I>)

( ref: SynchronizedRef.SynchronizedRef<HashMap.HashMap<EventStreamId, SubscriptionData<T>>>, streamId: Eve

()