EventLogRemote

declare class RemoteAdditions extends ReadonlySide<{
  readonly _tag: tag<"RemoveAdditions">;
  readonly entries: $Array<typeof RemoteEntry>;
}, "Type"> {
  constructor(...args: [props: {
    readonly _tag?: "RemoveAdditions";
    readonly entries: readonly Array<RemoteEntry>;
  }, options?: MakeOptions]);
}

declare function fromSocket(options?: { readonly disablePing?: boolean }): Effect<void, never, any>;

declare function fromWebSocket(
  url: string,
  options?: {
    readonly disablePing?: boolean;
  },
): Effect<void, never, any>;

declare function layerWebSocket(
  url: string,
  options?: {
    readonly disablePing?: boolean;
  },
): Layer<never, never, any>;

declare function layerWebSocketBrowser(
  url: string,
  options?: {
    readonly disablePing?: boolean;
  },
): Layer<never, never, EventLog>;

interface EventLogRemote {
  readonly changes: (identity: any, startSequence: number) => Effect<ReadonlyMailbox<RemoteEntry>, never, Scope>;
  readonly id: any;
  readonly write: (identity: any, entries: readonly Array<Entry>) => Effect<void>;
}

declare class Ack extends ReadonlySide<{
  readonly _tag: tag<"Ack">;
  readonly id: Number;
  readonly sequenceNumbers: $Array<Number>;
}, "Type"> {
  constructor(...args: [props: {
    readonly _tag?: "Ack";
    readonly id: number;
    readonly sequenceNumbers: readonly Array<number>;
  }, options?: MakeOptions]);
}

declare class Changes extends ReadonlySide<{
  readonly _tag: tag<"Changes">;
  readonly entries: $Array<Struct<{
    readonly encryptedEntry: any;
    readonly entryId: any;
    readonly iv: any;
    readonly sequence: Number;
  }>>;
  readonly publicKey: String;
}, "Type"> {
  constructor(...args: [props: {
    readonly _tag?: "Changes";
    readonly entries: readonly Array<{
      [key: string]: any;
    }>;
    readonly publicKey: string;
  }, options?: MakeOptions]);
}

declare class ChunkedMessage extends {
  [key: string]: any;
} {
  [key: string]: any;
  constructor(...args: [props?: {
    [key: string]: any;
  }, options?: MakeOptions]);
  static join(map: Map<number, {
    bytes: number;
    count: number;
    readonly parts: Array<Uint8Array<ArrayBufferLike>>;
  }>, part: ChunkedMessage): Uint8Array<ArrayBufferLike> | undefined;
  static split(id: number, data: Uint8Array): readonly Array<ChunkedMessage>;
}

declare const decodeRequest: (input: any, options?: ParseOptions) => any;

declare const decodeResponse: (input: any, options?: ParseOptions) => any;

declare const encodeRequest: (input: any, options?: ParseOptions) => any;

declare const encodeResponse: (input: any, options?: ParseOptions) => any;

declare class Hello extends {
  [key: string]: any;
} {
  [key: string]: any;
  constructor(...args: [props?: {
    [key: string]: any;
  }, options?: MakeOptions]);
}

declare class Ping extends ReadonlySide<
  {
    readonly _tag: tag<"Ping">;
    readonly id: Number;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: {
        readonly _tag?: "Ping";
        readonly id: number;
      },
      options?: MakeOptions,
    ]
  );
}

declare class Pong extends ReadonlySide<
  {
    readonly _tag: tag<"Pong">;
    readonly id: Number;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: {
        readonly _tag?: "Pong";
        readonly id: number;
      },
      options?: MakeOptions,
    ]
  );
}

declare const ProtocolRequest: Union<readonly Array<Constraint>>

declare const ProtocolRequestMsgPack: any;

declare const ProtocolResponse: Union<readonly Array<Constraint>>

declare const ProtocolResponseMsgPack: any;

declare class RequestChanges extends ReadonlySide<
  {
    readonly _tag: tag<"RequestChanges">;
    readonly publicKey: String;
    readonly startSequence: Number;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: {
        readonly _tag?: "RequestChanges";
        readonly publicKey: string;
        readonly startSequence: number;
      },
      options?: MakeOptions,
    ]
  );
}

declare class StopChanges extends ReadonlySide<
  {
    readonly _tag: tag<"StopChanges">;
    readonly publicKey: String;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: {
        readonly _tag?: "StopChanges";
        readonly publicKey: string;
      },
      options?: MakeOptions,
    ]
  );
}

declare class WriteEntries extends {
  [key: string]: any;
} {
  [key: string]: any;
  constructor(...args: [props?: {
    [key: string]: any;
  }, options?: MakeOptions]);
}