import { DataViewReader, FieldType } from "./reader.mjs";

//#region src/packet.d.ts
interface NumStartFinish {
  start: number;
  finish?: number;
}
interface BigStartFinish {
  start: bigint;
  finish?: bigint;
}
interface FlagSet {
  set: {
    [flag: string]: number;
  };
}
interface BigFlagSet {
  set: {
    [flag: string]: bigint;
  };
}
interface SimpleBitsConfig<V extends number | bigint, W> {
  convert?(value: V, name: string): W;
}
type BitsConfig<From, To> = From extends (number | undefined) ? (NumStartFinish | FlagSet) & SimpleBitsConfig<number, To> : From extends (bigint | undefined) ? (BigStartFinish | BigFlagSet) & SimpleBitsConfig<bigint, To> : never;
interface EasyReadOpts {
  /**
   * If specified, override the endiannes of the stream.
   */
  littleEndian?: boolean;
}
type ConvertReadOpts<F extends FieldType, G> = [G] extends [F] ? {
  convert?(value: F, name: string, temp: boolean): G;
} : {
  /**
   * If specified, run the results through the given function before storing.
   * Required if the destination type is not the same as the read type.
   *
   * @param value Original read value.
   * @param name The field being stored to.  May be ignored.
   * @param temp Is the field being stored to in temp rather than packet?
   * @returns Converted value.
   */
  convert(value: F, name: string, temp: boolean): G;
};
type ReadOpts<F extends FieldType, G> = EasyReadOpts & ConvertReadOpts<F, G> & {
  /**
   * If true, write to temp instead of packet.
   */
  temp?: boolean;
};
type NotTemp<F extends FieldType, G> = EasyReadOpts & ConvertReadOpts<F, G> & {
  temp?: false;
};
type HasTemp<F extends FieldType, G> = EasyReadOpts & ConvertReadOpts<F, G> & {
  temp: true;
};
type MatchingType<T extends object, V extends keyof T, U> = T[V] extends (U | undefined) ? V : never;
/**
 * Capture fields from a packet in a way that allows accessing the previously-
 * read fields while reading subsequent fields.
 *
 * @template T Structure of the packet.
 * @template U Structure for other temporary fields that you want to reference,
 *   but don't want in the final packet.
 */
declare class Packet<T extends object, U = object> {
  #private;
  constructor(reader: DataViewReader);
  /**
   * Is the packet in littleEndian mode by default?
   *
   * @type {boolean}
   */
  get littleEndian(): boolean;
  set littleEndian(val: boolean);
  /**
   * Packet.  Only the fields that you have already read may be accessed.
   *
   * @returns Possibly-incomplete packet, even though the type is complete.
   */
  get packet(): T;
  /**
   * The current offset into the reader.
   *
   * @type {number}
   */
  get offset(): number;
  /**
   * How many bytes are left to be read?
   *
   * @type {number}
   */
  get left(): number;
  /**
   * Temporary storage.  Only the fields that you have already read may be
   * accessed.
   *
   * @returns Possibly-incomplete temp data, even though the type is complete.
   */
  get temp(): U;
  /**
   * Get the truncation mode of the underlying reader.
   *
   * @returns True if truncation allowed.
   */
  get allowTruncation(): boolean;
  /**
   * Sets the truncation mode of the underlying reader.  May not be set to
   * false.
   */
  set allowTruncation(val: boolean);
  /**
   * Is this underlying reader truncated?
   *
   * @returns True if truncated.
   */
  get truncated(): boolean;
  /**
   * Some higher-level processor has detected truncation.  Must not be set
   * to false.
   */
  set truncated(val: boolean);
  /**
   * Reset all packet data, temp data, and return reader to the start.
   * Mostly useful for testing.
   *
   * @returns This, for chaining.
   */
  reset(): this;
  /**
   * Assert that all of the data been read.  Throws an exception if extra
   * data.
   *
   * @returns This, for chaining.
   */
  complete(): this;
  /**
   * Turn on truncation for this stream.
   *
   * @returns This, for chaining.
   */
  enableTruncation(): this;
  /**
   * Skip over some bytes in the stream.
   *
   * @param length Number of bytes to skip.
   * @returns This, for chaining.
   */
  skip(length: number): this;
  /**
   * Store all of the data that has yet to be read.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  unused<V extends keyof T>(name: V, opts: NotTemp<Uint8Array, T[V]>): this;
  unused<V extends keyof T>(name: MatchingType<T, V, Uint8Array>): this;
  unused<V extends keyof U>(name: V, opts: HasTemp<Uint8Array, U[V]>): this;
  /**
   * Store some number of bytes.
   *
   * @param name Field to write to in packet or temp.
   * @param len Number of bytes to read.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  bytes<V extends keyof T>(name: V, len: number, opts: NotTemp<Uint8Array, T[V]>): this;
  bytes<V extends keyof T>(name: MatchingType<T, V, Uint8Array>, len: number): this;
  bytes<V extends keyof U>(name: V, len: number, opts: HasTemp<Uint8Array, U[V]>): this;
  /**
   * Store some number of bytes, interpreted as an ASCII string.
   *
   * @param name Field to write to in packet or temp.
   * @param len Number of bytes to read.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  ascii<V extends keyof T>(name: V, len: number, opts: NotTemp<string, T[V]>): this;
  ascii<V extends keyof T>(name: MatchingType<T, V, string>, len: number): this;
  ascii<V extends keyof U>(name: V, len: number, opts: HasTemp<string, U[V]>): this;
  /**
   * Store some number of bytes, interpreted as a UTF8 string.
   *
   * @param name Field to write to in packet or temp.
   * @param len Number of bytes to read.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  utf8<V extends keyof T>(name: V, len: number, opts: NotTemp<string, T[V]>): this;
  utf8<V extends keyof T>(name: MatchingType<T, V, string>, len: number): this;
  utf8<V extends keyof U>(name: V, len: number, opts: HasTemp<string, U[V]>): this;
  /**
   * Store an unsigned 8 bit integer.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  u8<V extends keyof T>(name: V, opts: NotTemp<number, T[V]>): this;
  u8<V extends keyof T>(name: MatchingType<T, V, number>): this;
  u8<V extends keyof U>(name: V, opts: HasTemp<number, U[V]>): this;
  /**
   * Store an unsigned 16 bit integer.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  u16<V extends keyof T>(name: V, opts: NotTemp<number, T[V]>): this;
  u16<V extends keyof T>(name: MatchingType<T, V, number>): this;
  u16<V extends keyof U>(name: V, opts: HasTemp<number, U[V]>): this;
  /**
   * Store an unsigned 32 bit integer.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  u32<V extends keyof T>(name: V, opts: NotTemp<number, T[V]>): this;
  u32<V extends keyof T>(name: MatchingType<T, V, number>): this;
  u32<V extends keyof U>(name: V, opts: HasTemp<number, U[V]>): this;
  /**
   * Store an unsigned 64 bit integer as a bigint.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  u64<V extends keyof T>(name: V, opts: NotTemp<bigint, T[V]>): this;
  u64<V extends keyof T>(name: MatchingType<T, V, bigint>): this;
  u64<V extends keyof U>(name: V, opts: HasTemp<bigint, U[V]>): this;
  /**
   * Store a signed 8 bit integer.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  i8<V extends keyof T>(name: V, opts: NotTemp<number, T[V]>): this;
  i8<V extends keyof T>(name: MatchingType<T, V, number>): this;
  i8<V extends keyof U>(name: V, opts: HasTemp<number, U[V]>): this;
  /**
   * Store a signed 16 bit integer.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  i16<V extends keyof T>(name: V, opts: NotTemp<number, T[V]>): this;
  i16<V extends keyof T>(name: MatchingType<T, V, number>): this;
  i16<V extends keyof U>(name: V, opts: HasTemp<number, U[V]>): this;
  /**
   * Store a signed 32 bit integer.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  i32<V extends keyof T>(name: V, opts: NotTemp<number, T[V]>): this;
  i32<V extends keyof T>(name: MatchingType<T, V, number>): this;
  i32<V extends keyof U>(name: V, opts: HasTemp<number, U[V]>): this;
  /**
   * Store a signed 64 bit integer as a bigint.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  i64<V extends keyof T>(name: V, opts: NotTemp<bigint, T[V]>): this;
  i64<V extends keyof T>(name: MatchingType<T, V, bigint>): this;
  i64<V extends keyof U>(name: V, opts: HasTemp<bigint, U[V]>): this;
  /**
   * Store a 16 bit float.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  f16<V extends keyof T>(name: V, opts: NotTemp<number, T[V]>): this;
  f16<V extends keyof T>(name: MatchingType<T, V, number>): this;
  f16<V extends keyof U>(name: V, opts: HasTemp<number, U[V]>): this;
  /**
   * Store a 32 bit float.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  f32<V extends keyof T>(name: V, opts: NotTemp<number, T[V]>): this;
  f32<V extends keyof T>(name: MatchingType<T, V, number>): this;
  f32<V extends keyof U>(name: V, opts: HasTemp<number, U[V]>): this;
  /**
   * Store a 64 bit float.
   *
   * @param name Field to write to in packet or temp.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  f64<V extends keyof T>(name: V, opts: NotTemp<number, T[V]>): this;
  f64<V extends keyof T>(name: MatchingType<T, V, number>): this;
  f64<V extends keyof U>(name: V, opts: HasTemp<number, U[V]>): this;
  /**
   * Convenience function to repeat reading a given number of times.
   *
   * @param name Packet field name to read into, as an array.
   * @param num Number of times to call fn.
   * @param fn Function that reads.
   * @param opts Read options.
   * @returns This, for chaining.
   */
  times<V extends keyof T>(name: V, num: number, fn: (n: number) => FieldType, opts: NotTemp<FieldType[], T[V]>): this;
  times<V extends keyof T>(name: MatchingType<T, V, FieldType[]>, num: number, fn: (n: number) => FieldType): this;
  times<V extends keyof U>(name: V, num: number, fn: (n: number) => FieldType, opts: HasTemp<FieldType[], U[V]>): this;
  /**
   * Convenience function to perhaps execute a read.  Does not call the
   * function if input was truncated.
   *
   * @param doIt Should fn be executed?
   * @param fn Run if doIt is true.
   * @returns This, for chaining.
   */
  maybe(doIt: boolean, fn: () => void): this;
  /**
   * Repeat the given read until a condition fails.
   *
   * @param name Packet field name to read into, as an array.
   * @param keepGoing While this function returns true, keep calling read.
   * @param read The value returned from this function is added to the array.
   * @param opts Read options.
   */
  while<V extends keyof T>(name: V, keepGoing: (iteration: number, r: DataViewReader) => boolean, read: (iteration: number, r: DataViewReader) => T[V] extends (Iterable<infer E> | undefined) ? E : never, opts?: EasyReadOpts): this;
  while<V extends keyof U, W extends FieldType>(name: V, keepGoing: (iteration: number, r: DataViewReader) => boolean, read: (iteration: number, r: DataViewReader) => U[V] extends (Iterable<infer E> | undefined) ? E : never, opts: HasTemp<W[], U[V]>): this;
  /**
   * Copy some of the bits from one existing field to another.  Does
   * not work for fields larger than 53 bits.  For fields larger than
   * 32 bits, use bigints, as returned from u64().  Should only be
   * applied to unsigned from fields.  Bits are numbered with 0 on the
   * right, MSB on the left.  Start and finish can be in either order.
   *
   * @param desc Description of bits to capture.
   */
  bits<V extends keyof T, W extends keyof T>(desc: {
    from: T[V] extends number | bigint | undefined ? V : never;
    to: W;
  } & BitsConfig<T[V], T[W]>): this;
  bits<V extends keyof U, W extends keyof T>(desc: {
    fromTemp: U[V] extends number | bigint ? V : never;
    to: W;
  } & BitsConfig<U[V], T[W]>): this;
  bits<V extends keyof T, W extends keyof U>(desc: {
    from: T[V] extends number | bigint ? V : never;
    toTemp: W;
  } & BitsConfig<T[V], U[W]>): this;
  bits<V extends keyof U, W extends keyof U>(desc: {
    fromTemp: U[V] extends number | bigint ? V : never;
    toTemp: W;
  } & BitsConfig<U[V], U[W]>): this;
  /**
   * Store a constant to the packet.
   *
   * @param name Field to write to in packet or temp.
   * @param val Any constant value.
   * @param opts Read options.
   */
  constant<V extends keyof T, F extends FieldType>(name: V, val: F, opts: NotTemp<F, T[V]>): this;
  constant<V extends keyof T, F extends FieldType>(name: MatchingType<T, V, F>, val: F): this;
  constant<V extends keyof U, F extends FieldType>(name: V, val: F, opts: HasTemp<F, U[V]>): this;
}
//#endregion
export { BigFlagSet, BigStartFinish, BitsConfig, ConvertReadOpts, DataViewReader, EasyReadOpts, type FieldType, FlagSet, HasTemp, MatchingType, NotTemp, NumStartFinish, Packet, ReadOpts, SimpleBitsConfig };