If you're looking for a specific solution instead of a generic one, consider the following:

MyNewType = { a: string }
          | { b: string }
          | { c: string }
          | { d: string | undefined }
          | { d: string | undefined };

Finding a way to do this for a generic type T is challenging.

One alternative approach could be using separate properties for key and value like this:

{
  key: "a",
  value: "a"
}

This could potentially be achieved in a generic manner:

type MyNewType<T> = {
  key: keyof T;
  value: T[keyof T];
}

However, this method allows combining any key with any value, which may not be precise.

Another option is:

type MyNewType<T, K extends keyof T> = {
  key: K;
  value: T[K];
}

This improved version introduces a new type parameter to represent the key type. For instance, it can be used as follows:

function dispatch<K extends keyof Test>(testPayload: MyNewType<Test, K>) {
  // perform actions on payload
}

dispatch({ key: "a", value: "a" });        // OK
dispatch({ key: "a", value: undefined });  // Error, because Test.a cannot be undefined
dispatch({ key: "d", value: undefined });  // OK
dispatch({ key: "x", value: undefined });  // Error, since Test doesn't have property "x"

Edit

I also attempted the following to create a type exactly as requested:

type MyNewType<T, K extends keyof T> = {
  [key: K]: T[K];
}

Nevertheless, TypeScript throws an error related to the key:

An index signature parameter type must be either 'string' or 'number'.

To mark optional keys, simply add a ? at the end

For example, if you want to specify that a and b are optional:

interface Test {
  a?: string;
  b?: string;
  c: string;
  d: string | undefined;
  e: string | undefined;
}

Learn more about optional properties in TypeScript from this source

The individual who posed this inquiry nearly nailed it, achieving a 99% accuracy rate on his own. However, there is just one tiny detail missing:)

To address this, simply make the key optional:

type MyModifiedType<T> = {
  [key in keyof T]?: T[key];
};

Unique solution

In my experience with TypeScript 5.0, the following approach has proven effective:

type ExtractOneProp<T> = {
    [K in keyof T]: { [_ in K]: T[K] }
}[keyof T]

Insight

For instance, applying this type transformation to:

type SampleType = ExtractOneProp<{ x: 'apple', y: 'banana'}>

would yield

type SampleType = {
    x: { x: 'apple' },
    y: { y: 'banana' },
}['x' | 'y']

resulting in

type SampleType = { x: 'apple' } | { y: 'banana' }

Application

This methodology showcases how verifying membership aids in deducing the precise type:

function accessPropertyValue(obj: ExtractOneProp<{ x: 'apple', y: 'banana' }>) {
    if ('x' in obj) {
        // obj is determined to be { x: 'apple' } due to the presence of 'x'
        return obj.x
    } else if ('y' in obj) {
        // obj is determined to be { y: 'banana' } as 'y' exists
        return obj.y
    } else {
        // obj is inferred to be { z: 'carrot' } since neither 'x' nor 'y' is included
        obj.z
    }
}

Constraints

Notably, this method mandates that at least one property from T must be present--permitting multiple properties does not trigger an error.

type SampleType = ExtractOneProp<{ x: 'apple', y: 'banana', z: 'carrot' }> // Resolves to { x: 'apple' } | { y: 'banana' } | { z: 'carrot' }

const example1: SampleType = { x: 'apple' } // Allowed
const example2: SampleType = { y: 'banana', z: 'carrot' } // Permitted: Singular property requirement not enforced
const example3: SampleType = {} // ERROR: Type '{}' cannot be assigned to 'SampleType'

Dealing with a similar issue, I devised a unique solution.

To address this, create an interface or type that encompasses all the properties you desire to support. However, make them optional and of type never. While you can utilize these properties, you are unable to assign any values to them.

interface BaseType {
  a?: never;
  b?: never;
  c?: never;
  d?: never;
  e?: never;
}

For each property, fashion a type by excluding the base never property and substituting it with the desired type. It is no longer optional at this point.

type AType = Omit<BaseType, "a"> & { "a": string };
type BType = Omit<BaseType, "b"> & { "b": string };
type CType = Omit<BaseType, "c"> & { "c": string };
type DType = Omit<BaseType, "d"> & { "d": string | undefined };
type EType = Omit<BaseType, "e"> & { "e": string | undefined };

Combine these individual types for single properties to form your MyNewType. Any instance of this type must align with one of the aforementioned types.

type MyNewType = AType | BType | CType | DType | EType;

The code snippets below either compile successfully or prompt TypeScript errors:

let testA : MyNewType = { "a": "test" } // A is present and is a string
let testB : MyNewType = { "b": 1 } // B is present but cannot be a number 
let testD : MyNewType = { "d": undefined } // D is present and may be undefined 
let testMultiple : MyNewType = { "a": "Some String", "b": "Another String" } // Multiple properties inclusion is not allowed

This setup has also been implemented in the Playground, providing real-time observation of the TypeScript errors.

I encountered a similar issue and found a solution by utilizing the concept of Partial in my code:

For instance:

interface Example {
  x: string;
  y: string;
  z: string;
  u: string | undefined;
  v: string | undefined;
}

// To address the issue, I introduced Partial
type RevisedType<T> = Partial<
  {
    [key in keyof T]: T[key];
  }
>;

Actually, there is a generic way to accomplish this task:

In short: enhanced by using Matt's method to make other properties optional and never have a type

    type NoProperties<T> = {
        [K in keyof T]?: never;
    }

    type SingleProperty<T> = {
        [K in keyof T]: Omit<NoProperties<T>, K> & { [P in K]: T[P] };
    }[keyof T];

Specifics:

The interface you are working with:

    interface Test {
        a: string;
        b: string;
        c: string;
        d: string | undefined;
        e: string | undefined;
    }

By using this generic type:

    type SinglePropertyIntermediate<T> = {
        [K in keyof T]: { [P in K]: T[P] };
    };

You will receive:

    {
        a: { a: string; };
        b: { b: string; };
        c: { c: string; };
        d: { d: string | undefined; };
        e: { e: string | undefined; };
    }

Now, extract the values of this object type:

    type SingleProperty<T> = SinglePropertyIntermediate<T>[keyof T]

This results in:

    { a: string; } |
    { b: string; } |
    { c: string; } |
    { d: string | undefined; } |
    { e: string | undefined; };

Building upon S.Young's solution

You can induce errors with multiple properties by incorporating the 'never' type

export type OneOf<T> = {
  [K in keyof T]: { [_ in K]: T[K] } & Partial<
    Record<Exclude<keyof T, K>, never>
  >;
}[keyof T];

Instructions:

type Bar = OneOf<{ x: 1, y: 2, z: 3 }>;

// Acceptable scenarios
const example1: Bar = { x: 1 }; // Valid
const example2: Bar = { y: 2 }; // Valid
const example3: Bar = { z: 3 }; // Valid

// Inappropriate scenarios
const example4: Bar = { x: 1, y: 2 }; // Error: Type '{ x: 1; y: 2; }' is not assignable to type 'Bar'
const example5: Bar = { y: 2, z: 3 }; // Error: Type '{ y: 2; z: 3; }' is not assignable to type 'Bar'
const example6: Bar = {}; // Error: Type '{}' is not assignable to type 'Bar'