export declare class UnreachableError extends Error {
    /** @param x an unreachable value */
    constructor(x: never);
}
export declare type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
export declare type RequiredBy<T, K extends keyof T> = Omit<T, K> & {
    [F in K]-?: Exclude<T[F], undefined>;
};
/**
 * Convert a map type { [key]: value } into an map of key/value types.
 * For example, `{ A: 'B' }` becomes `{ A: { key: 'A', value: 'B' } }`.
 */
declare type KeyValuePairs<T extends Record<PropertyKey, PropertyKey>> = {
    [K in keyof T]: {
        key: K;
        value: T[K];
    };
}[keyof T];
/**
 * Inverts a type map.
 * For example, `{ foo: 'bar' }` becomes `{ bar: 'foo'}`.
 */
export declare type Invert<T extends Record<PropertyKey, PropertyKey>> = {
    [K in KeyValuePairs<T>['value']]: Extract<KeyValuePairs<T>, {
        value: K;
    }>['key'];
};
/**
 * Replace the types of keys in T with matching type in the LookUp record.
 *
 * @example
 *
 * type Foo = { A: 'B' };
 * type LookUp = { 'B': number };
 * const foo: MatchKeyType<Foo, LookUp> = { A: 123 };
 */
declare type MatchKeyType<T extends Record<PropertyKey, any>, LookUp extends Record<PropertyKey, any>> = {
    [K in KeyValuePairs<T>['key']]: LookUp[Extract<KeyValuePairs<T>, {
        key: K;
    }>['value']];
};
/**
 * Create an new type from a type and a key map.
 * Where C, is a key name map between the source datatype T and the new type.
 * O represents a key value map of overrides to be applied to the new type
 * where the type of T is not the desire type.
 *
 * @example
 *
 * const keyNameMap = {
 *   value: 'new_value',
 *   name: 'new_name',
 * } as const;
 * type DataType = {
 *   value: number,
 *   name: string,
 * };
 * type NewDataType = MapDataType<typeof keyNameMap, DataType, { new_name: number }>;
 *
 * const foo: NewDataType = {
 *   new_value: 1,
 *   new_name: 2,
 * };
 */
export declare type MapDataType<C extends Record<keyof T, string>, T extends Record<PropertyKey, any>, O extends Partial<Record<keyof Invert<C>, any>> = {}> = Omit<MatchKeyType<Invert<C>, T>, keyof O> & O;
export {};