How to get the value type from a record in Typescript

I have a function which returns a record: ReturnType: Record<string, {...<SOME_BIG_TYPE>...}>, and another function that I would like to accept {...<SOME_BIG_TYPE>...} as an argument. How can I grab that type from the record?

I would like something like the following where ExtractedValueOf grabs that value I mentioned earlier.

const function = ({ bigObject }: { bigObject: ExtractedValueOf<ReturnType> }) => null;

I was thinking something like ReturnType<keyof ReturnType> but this does not work.

Edit: Added a basic example that illustrates my issue.

I have here a function that returns Record<string, SomeType>, which is used to call my other function, which takes an argument of SomeType. This is all typesafe and how I would expect it to work:

type SomeType = {
  field: string;
  another: string;
};

function sample(): Record<string, SomeType> {
  return {
    object: {
      field: "Hello",
      another: "World",
    },
  };
}

function myFunction() {
  return myOtherFunction(sample().object);
}

function myOtherFunction(sampleObject: SomeType) {
  // something in here
  return sampleObject;
}

The problem is, in the place I have defined myOtherFunction, I don't have access to SomeType directly. I have access to the return type from sample, but I can't figure out how to get SomeType out of Record<string, SomeType>

You don't need to.

Typescript is duck-typed. Just define myOtherFunction as

function myOtherFunction<T>(sampleObject: T) {...}

and let the tranpiler do its thing. If myOtherFunction requires the argument's another property to be a string then any argument being passed must extend {another: NonNullable<string>}.

But if you want to tightly couple the code so that any change in SomeType's definition affects both places independently then your question resolves to: "How can I do static code evaluation when the type definitions aren't available at compile time?"

Or am I missing something?

Thanks very much to h-sifat. I did initially try ReturnType[string] before posting, but that evaluated to never. Turns out it was because ReturnType in my case was either the record or undefined. The fix was NonNullable<ReturnType>[string].