export type ColumnAccessor<T = any> = string | ((item: T) => any);

export type GroupKey<T = any> = ColumnAccessor<T> | Array<ColumnAccessor<T>>;

export type AggregateEntry = [string, ColumnAccessor?, number?];

export type AggregateEntries = AggregateEntry | AggregateEntry[];

export type OrderDirection = "asc" | "desc" | "ASC" | "DESC";

export interface GroupByOptions {
  /**
   * When true, throw if a string grouping key is missing on any object.
   * Default: missing keys are grouped under `"undefined"`.
   */
  strict?: boolean;
}

export interface AggregateSpec {
  sum?: AggregateEntries;
  avg?: AggregateEntries;
  min?: AggregateEntries;
  max?: AggregateEntries;
  distinctCount?: AggregateEntries;
  count?: [string] | [string][];
}

export interface GroupRow<T = any> {
  key: any;
  items?: T[];
  [alias: string]: any;
}

export interface GroupBucket<T = any> {
  items?: T[];
  [alias: string]: any;
}

export interface GroupResult<T = any> {
  data: Record<string, GroupBucket<T>>;
  sum(alias: string, columnName: ColumnAccessor<T>): GroupResult<T>;
  min(alias: string, columnName: ColumnAccessor<T>): GroupResult<T>;
  max(alias: string, columnName: ColumnAccessor<T>): GroupResult<T>;
  avg(
    alias: string,
    columnName: ColumnAccessor<T>,
    decimals?: number
  ): GroupResult<T>;
  distinctCount(alias: string, columnName: ColumnAccessor<T>): GroupResult<T>;
  count(alias: string): GroupResult<T>;
  aggregate(spec: AggregateSpec): GroupResult<T>;
  reduce(
    alias: string,
    reducer: (accumulator: any, item: T, index: number, items: T[]) => any,
    initial?: any
  ): GroupResult<T>;
  orderBy(
    field: "key" | string | ((group: GroupBucket<T>, key: any) => any),
    direction?: OrderDirection
  ): GroupResult<T>;
  omitItems(): GroupResult<T>;
  where(predicate: (item: T) => boolean): GroupResult<T>;
  toArray(): GroupRow<T>[];
  readonly keys: any[];
  readonly firstGroup: T[];
  readonly lastGroup: T[];
}

declare function groupBy<T = any>(
  data: T[],
  key: GroupKey<T>,
  options?: GroupByOptions
): GroupResult<T>;

declare const groupjs_by: {
  groupBy: typeof groupBy;
};

export = groupjs_by;