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;