Улучшение результируюзих типов

[Pomkaize]

import * as de from 'descript';

interface ParamsTop {
    param1: string;
    param2: string;
}

interface ParamsResource1 {
    resourceParams: string;
}
interface ParamsResource2 {
    resourceParams2: string;
}
interface ParamsResource3 {
    resourceParams3: string;
}

const resource2 = de.func({
    block: ({ params }: { params: ParamsResource2 }) => {
        console.log('result2');
        return 'resource2 result'
}});

const resource3 = de.func({
    block: ({ params }: { params: ParamsResource3 }) => {
        console.log('result3');
        return 'resource3 result'
}});

const block1 = de.func({
    block: ({ params }: { params: ParamsTop }) => {
        return de.object({
            block: {
                resource1: de.func({
                    block: ({ params }: { params: ParamsResource1 }) => {
                        console.log('result1');
                        return 'resource1 result'
                    },
                    options: {
                        // надо учитывать required и убирать из union возможную DescriptError
                        required: true
                    }
                }),
                combined: de.object({
                    block: {
                        resource2,
                        resource3,
                    },
                    options: {
                        // надо учитывать required и убирать из union возможную DescriptError
                        required: true
                    }
                }),
            }
        });
    },
    options: {
        error: () => {
            return {
                onError: 1,
            };
        },
        params: ({ params }) => {
            return {
                param1: params.param1,
                param2: params.param2,
                additionalParam: '1234'
            };
        },
    },
});

// надо экспортнуть этот тип
// надо этот тип запроцессить, чтобы убрать лишнее 
type ResTest = de.InferResultFromBlock<typeof block1>;

// надо учитывать required
// еще мб можно тип заново через infer прогнать, чтобы оставить его без Generic-ов для удоства чтения
const a: ResTest = {
    resource1: '', // string | de.DescriptError
    combined: {
        resource2:  // string | de.DescriptError,
        resource3:  // string | de.DescriptError
    }
}


de.run(block1, {
    params: {
        param1: 'param1',
        param2: 'param2',
    },
})
    .then((result) => {
        'executed';

        console.log(result);
    });

Хочется 3 вещи

1. Учитывать required в описании блоков и не делать union из res | de.DescriptError
2. Экспортировать из descript джинерик InferResultFromBlock
3. Результирующий тип от InferResultFromBlock прогнать через prettify тип, чтобы был проще
   https://youtu.be/kBwY8gc5tJU?t=1540