export interface ISerializeObject<T> {
  serializeKey(key: string): void
  serializeValue<U>(value: U): void
  serializeEntry<U>(key: string, value: U): void
  end(): T
}

export abstract class SerializeObject<T> implements ISerializeObject<T> {
  abstract serializeKey(key: string): void
  abstract serializeValue<U>(value: U): void
  abstract end(): T

  serializeEntry<U>(key: string, value: U): void {
    this.serializeKey(key)
    this.serializeValue(value)
  }
}

export interface ISerializeIterable<T> {
  serializeElement<U>(value: U): void
  end(): T
}

export abstract class SerializeIterable<T> implements ISerializeIterable<T> {
  abstract serializeElement<U>(value: U): void
  abstract end(): T
}

export interface ISerializer<T> {
  serializeAny?(value: any): T
  serializeBoolean(value: boolean): T
  serializeNumber(value: number): T
  serializeBigInt(value: bigint): T
  serializeString(value: string): T
  serializeSymbol(value: symbol): T
  serializeNull(): T
  serializeIterable(len?: number): ISerializeIterable<T>
  serializeObject(len?: number): ISerializeObject<T>
  serializeClass(name: string, len?: number): ISerializeObject<T>
}

export class Serializer<T> implements ISerializer<T> {
  serializeAny(_value: any): T {
    throw new Error("Method not implemented.")
  }

  serializeBoolean(_value: boolean): T {
    throw new Error('Method not implemented.')
  }

  serializeNumber(_value: number): T {
    throw new Error('Method not implemented.')
  }

  serializeBigInt(_value: bigint): T {
    throw new Error('Method not implemented.')
  }

  serializeString(_value: string): T {
    throw new Error('Method not implemented.')
  }

  serializeSymbol(_value: symbol): T {
    throw new Error('Method not implemented.')
  }

  serializeNull(): T {
    throw new Error('Method not implemented.')
  }

  serializeIterable(_len: number): ISerializeIterable<T> {
    throw new Error("Method not implemented.")
  }

  serializeObject(_len: number): ISerializeObject<T> {
    throw new Error('Method not implemented.')
  }

  serializeClass(_name: string, _len: number): ISerializeObject<T> {
    throw new Error('Method not implemented.')
  }
}

export interface Serialize<T, U> {
  (serializer: ISerializer<T>, value: U): T
}