The way I would suggest doing this is to pull out the wordType field as a separate schema which you would then use within the z.object. Like:

const wordTypeSchema = z.enum(["verb", "adjective", "noun"]);
type WordType = z.infer<typeof wordTypeSchema>;
export const wordAPI = z.object({
  words: z.array(
    z.object({
      id: z.string(),
      word: z.string(),
      translation: z.string(),
      type: wordTypeSchema
    })
  )
});

and then I would just use the WordType type wherever else I needed just that value.

It is, however, possible to extract the type from your nested object like so:

type WordAPI = z.infer<typeof wordAPI>;
type WordType = WordAPI['words'][number]['type'];
//    ^- This will include `| null` because you used `.nullable`
// If you don't want the | null you would need to say
type WordTypeNotNull = Exclude<WordType, null>;

Again, I would recommend the first approach as it's more reusable and less susceptible to needing to be updated if the object changes shape for example.

I got it working by using <T> with ZodType<T> instead of <T extends ZodAnyType> with <T>. Almost works as intended, as undefined will be return beside number in the getLeafValue function.

type Leaf<T> = z.infer<ReturnType<typeof LeafSchema<z.ZodType<T>>>>
type NumberLeaf = Leaf<number>
//    ^? { value: number }

const getLeafValue = <T>(leaf: Leaf<T>) => leaf.value
const test = { 'value': 123 }
const val = getLeafValue(test)
//     ^? { value: number | undefined }

Wrapping the z.infer with a Required<> would fix it in this example, but would make optional value (when present) also required. So, that only half the solution...

Playground