Aetae

Если конфиг унаследован от "plugin:@typescript-eslint/recommended", то не нужен, он просто там уже прописан.

Суть же в том, что тебе может не понравиться набор правил recommended и ты можешь его выкинуть, набросав свой по вкусу. И тогда всё сломается. Потому лучше указывать парсер сразу явно.

Яб сделал так:

type WritableFields<T> = Partial<Pick<T, WritableKeys<T>>>;
export function createElement<K extends keyof HTMLElementTagNameMap>(tag: K, options?: WritableFields<HTMLElementTagNameMap[K]>): HTMLElementTagNameMap[K] {
  let element = document.createElement(tag)

  if (options) {
    // assign options
    Object.assign(element, options);
  }

  return element
}

Если нужно именно с перебором, то можно так:

type WritableFields<T> = Partial<Pick<T, WritableKeys<T>>>;
export function createElement<K extends keyof HTMLElementTagNameMap>(tag: K, options?: WritableFields<HTMLElementTagNameMap[K]>): HTMLElementTagNameMap[K] {
  let element = document.createElement(tag)

  if (options) {
    // assign options
    let option: keyof typeof options;
    for (option in options) {
      element[option] = options[option]!; // ! - потому что теоретически ты можешь передать undefined явно, но морочиться с этим не стоит
    }
  }

  return element
}

P.S. Вообще все сложности с перебором переданного объекта в typescript происходят из того, что типизация в нём структураная: например имея интерфейс параметра, например,

interface Foo {
  foo: number;
}

тебе ничего не мешает передать ему

{
  foo: 1,
  bar: 2
}

, т.к. данный объект расширяет интерфейс Foo и, соответственно, удовлетворяет ему. Получается, что внутри функции typescript никак не может быть уверен, что ключи указанные в интерфейсе - это ВСЕ ключи, а значит не может быть уверен, что при переборе и присвоении не будет присвоено что-то лишнее. (Это не говоря уже о прототипах, геттерах и прочем)
Потому и требуется куча плясок, увы.

В ts структурная типизация. Такое может происходить если Snapshot структурно укладывается в тип Volume.

Т.е. вот так типы взаимозаменяемы:

interface Volume {
 id: number;
 volume?: string;
}

interface Snapshot {
 id: number;
 snapshot?: string;
}

А так нет:

interface Volume {
 id: number;
 volume: string;
}

interface Snapshot {
 id: number;
 snapshot: string;
}

И так нет:

interface Volume {
 id?: number;
}

interface Snapshot {
 id?: string;
}

В обзем шляпа у них с документацией и примерами. Ни в одном примере они не используют объекты вообще, также как нигде нет ни одного примера типизированного объекта. Из чего могу сделать вывод, что с типизированными объектами они не могут работать вообще. Но это не точно.

Работает например подобная херотень:

export class IResultItem {
  constructor(
    public id: i32,
    public type: string,
    public date: string,
    public from: string,
    public from_id: i32,
    public text: string
  ) {}
}
export function add(
  result: IResultItem[] = [new IResultItem( 1, "type", "25.25.2025", "rew", 123, "hello" )]
): IResultItem[] {
return result;
}

Тут понадобится немного магии:

type ClearIndex<T> = {
  [ P in keyof T as string extends P ? never : P ] : T[P]
};
class FOO implements ClearIndex<Service_FOO > {
    methodFoo() {}
}

Суть проблемы в том что Record<string, () => void> имеет "index signature", т.е. заявляет, что обращение по любому ключу stringвернёт () => void.
Service_FOO расширяет этот тип(а не сужает), потому Service_FOO имеет ту же index signature и уточнённый конкретный метод.
Класс же в ts не может иметь index signature, т.к. является строгой и конкретной структурой.

Можно, если им явно не указать тип Args, но тогда вы теряете предварительную проверку, увы:

let a1 = {
    channelID: {
        RegExp: ["\\d+", true],
        description: "d1"
    },
    content: {
        RegExp: [".+", true],
        description: "d2"
    }
};
type T1 = {[K in keyof typeof a1]: string}

Чтобы сохранить проверку - придётся воспользоваться дополнительной бессмысленной функцией для уточнения типа:

type Args = {
    [key: string]: {
        RegExp: [string, boolean],
        description: string
    }
}
function createArgs<T extends Args>(args: T): T {
    return args;
}

type TStringKeys<T extends Args> = {[K in keyof T]: string};


let a1 = createArgs({
    channelID: {
        RegExp: ["\\d+", true],
        description: "d1"
    },
    content: {
        RegExp: [".+", true],
        description: "d2"
    }
});

type T1 = TStringKeys<typeof a1>

К сожалению на текущий момент(ts4.2.3) избавиться от функции-обёртки не получится.

interface IOrder {
    date: string,
    docTypesName: string,
    docId: number,
    image: string,
    name: string,
    price: number,
    quantity: number,
    removed: number,
}

interface  IProduct {
    image: string,
    name: string,
    price: number,
    quantity: number,
}

interface IDocument {
    date: string,
    docId: number,
    docTypesName: string,
    products: IProduct[],
}

interface IElement {
    date: string,
    documents: IDocument[]
}

interface IElementMap {
    date: string,
    documents: Record<string, IDocument>
}

type IResultMap = Record<string, IElementMap>;

function f(orders: IOrder[]): IElement[] {
    const result = orders.reduce((accumulator, currentValue) => {
        const date = currentValue.date.split(' ')[0];

        if (!accumulator[date]) {
            accumulator[date] = {
                date,
                documents: {},
            }
        }

        if (!accumulator[date].documents[currentValue.docTypesName]) {
            accumulator[date].documents[currentValue.docTypesName] = {
                date: currentValue.date,
                docId: currentValue.docId,
                docTypesName: currentValue.docTypesName,
                products: [],
            }
        }

        accumulator[date].documents[currentValue.docTypesName].products.push({
            name: currentValue.name,
            price: currentValue.price,
            image: currentValue.image,
            quantity: currentValue.quantity,
        })

        return accumulator;
    }, {} as IResultMap)

    console.log('result', result);

    return Object.values(result).map(currentValue => {
        console.log('currentValue', currentValue);

        return {
            ...currentValue,
            documents: Object.values(currentValue.documents)
        }
    });
}

console.log(f(orders));

Array<Array<Record<string, string>>>

Хз, что за fastify но если он поддерживает и js и ts - может оставить заботу о типах на того, кто захочет использовать ваш плагин(хоть это и моветон).
Если он использует только ts, то используя его, вы, очевидно, должны знать ts. В такому случае сделайте именно то, что вам пишет консоль: сделайте соответствующий файл декларации.