如何在 Typescript 中的现有类型中选择或访问索引器/索引签名属性

Question

Edit: Changed title to reflect the problem properly.

I am trying to pick the exact type definition of a specific property inside a interface, but the property is a mapped type [key: string]: . I tried accessing it using T[keyof T] because it is the only property inside that type but it returns never type instead.

is there a way to like Pick<Interface, [key: string]> or Interface[[key: string]] to extract the type?

The interface I am trying to access is type { AWS } from '@serverless/typescript';

 export interface AWS { configValidationMode?: "error" | "warn" | "off"; deprecationNotificationMode?: "error" | "warn" | "warn:summary"; disabledDeprecations?: "*" | ErrorCode[]; frameworkVersion?: string; functions?: { [k: string]: { // <--- Trying to pick this property. name?: string; events?: ( | { __schemaWorkaround__: null; } | { schedule: | string | { rate: string[]; enabled?: boolean; name?: string; description?: string; input?: | string /// Didn't include all too long..

Answer 1

You can use indexed access types here. If you have an object-like type T and a key-like type K which is a valid key type for T , then T[K] is the type of the value at that key. In other words, if you have a value t of type T and a value k of type K , then t[k] has the type T[K] .

So the first step here is to get the type of the functions property from the AWS type:

type Funcs = AWS["functions"];
/* type Funcs = {
    [k: string]: {
        name?: string | undefined;
        events?: {
            __schemaWorkaround__: null;
        } | {
            schedule: string | {
                rate: string[];
                enabled?: boolean;
                name?: string;
                description?: string;
                input?: string;
            };
        } | undefined;
    };
} | undefined */

Here AWS corresponds to the T in T[K] , and the string literal type "functions" corresponds to the K type.

Because functions is an optional property of AWS , the Funcs type is a union of the declared type of that property with undefined . That's because if you have a value aws of type AWS , then aws.functions might be undefined . You can't index into a possibly undefined value safely, so the compiler won't let you use an indexed access to type to drill down into Funcs directly. Something like Funcs[string] will be an error.

---

So first we need to remove filter out the undefined type from Functions . The easiest way to do this is with the NonNullable<T> utility type which filters out null and undefined from a union type T :

type DefinedFuncs = NonNullable<Funcs>;
/* type DefinedFuncs = {
    [k: string]: {
        name?: string | undefined;
        events?: {
            __schemaWorkaround__: null;
        } | {
            schedule: string | {
                rate: string[];
                enabled?: boolean;
                name?: string;
                description?: string;
                input?: string;
            };
        } | undefined;
    };
} */

Okay, now we have a defined type with a string index signature whose property type is the type we're looking for. Since any string -valued key can be used to get the property we're looking for, we can use an indexed access type with DefinedFuncs as the object type and string as the key type:

type DesiredProp = DefinedFuncs[string];
/* type DesiredProp = {
    name?: string | undefined;
    events?: {
        __schemaWorkaround__: null;
    } | {
        schedule: string | {
            rate: string[];
            enabled?: boolean;
            name?: string;
            description?: string;
            input?: string;
        };
    } | undefined;
} */

Looks good: And of course we can do this all as a one-liner:

type DesiredProp = NonNullable<AWS["functions"]>[string];

Playground link to code