Sse

declare const encoder: Encoder

declare function makeChannel<IE, Done>(options?: DecodeOptions & {
  readonly bufferSize?: number;
}): Channel<Chunk<Event>, Chunk<string>, IE, IE, void, Done>

declare function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeOptions): Parser

declare class EventTooLarge extends YieldableError<this> & {
  readonly _tag: "EventTooLarge";
} & Readonly<{
  readonly maxEventSize: number;
}> {
  constructor(args: {
    readonly maxEventSize: number;
  });
  message: string;
}

declare class SseError extends YieldableError<this> & {
  readonly _tag: "SseError";
} & Readonly<{
  readonly cause: EventTooLarge;
}> {
  constructor(args: {
    readonly cause: EventTooLarge;
  });
  readonly "@effect/experimental/Sse/SseError": "@effect/experimental/Sse/SseError";
  message: string;
}

type SseErrorReason = EventTooLarge

type AnyEvent = Event | Retry

interface DecodeOptions {
  readonly maxEventSize?: number;
}

interface Encoder {
  write(event: AnyEvent): string;
}

interface Event {
  readonly _tag: "Event";
  readonly data: string;
  readonly event: string;
  readonly id: string | undefined;
}

interface EventEncoded {
  readonly data: string;
  readonly event: string;
  readonly id: string | undefined;
}

interface Parser {
  feed(chunk: string): SseError | undefined;
  reset(): void;
}

declare class Retry extends Readonly<{
  readonly duration: Duration;
  readonly lastEventId: string | undefined;
}> & {
  readonly _tag: "Retry";
} & Pipeable {
  constructor(args: {
    readonly duration: Duration;
    readonly lastEventId: string | undefined;
  });
  readonly [RetryTypeId]: typeof RetryTypeId;
  static is(u: unknown): u is Retry;
}

declare const RetryTypeId: unique symbol

type RetryTypeId = typeof RetryTypeId