"OK" is a string, and str is implicitly taking the type string in your code.

When you try to access an object's property, you need to use a type keyof. TypeScript then knows you are not assigning a random string; you are assigning strings compatible with the properties (keys) for the object.

Also, since status is a variable, not a type, you need to extract its type with typeof.

Try:

let str = "OK" as keyof typeof status;
status[str]; // 200

or more cleanly:

type StatusKey = keyof typeof status;
let str: StatusKey = "OK";
status[str]; // 200

// and to answer the question about reversal
status[status.OK as StatusKey]; // OK

See: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-1.html#keyof-and-lookup-types

You could do it like this

type inventory = typeof Inventory;
export const Inventory = {
    food: 0,
    medicine: 0,
    rifleAmmo: 0,
    pistolAmmo: 0
}

enum itemType {
    'rifle-ammo'
}
interface itemInterface {
    amount: number,
    item: keyof inventory
}
export const AddToInventory = ({amount, item}: itemInterface) => {
    return  Inventory[item]  = Inventory[item] + amount 
}

If you don't want to create a specific string-keyed type for your object, you'll need to create a general one for Javascript objects:

interface IPojo {
  [key: string]: any,
}

const div = document.createElement('div');

const obj: IPojo = {
  'data-src': 'some-url',
  'data-width': 2,
};

Object.keys(obj).forEach(key => div.setAttribute(key, obj[key]));

By declaring it an implementation of that string-keyed general interface, the typechecker will correctly infer that your dynamic access is ok.

If your object is homogenous in terms of values you can make this even more type-safe by using a generic:

interface IHomogenousObject<T> {
  [key: string]: T,
}

const obj2: IHomogenousObject<string> = {
  'data-src': 'some-url',
};

And now the compiler will preserve the type safety of the string value pulled from the object.

Here's the playground.

In order for this to work, you need to make things generic in both the type T of obj and the type K of prop, so that the type of the final result will be the indexed access type T[K].

Now if you were not writing a curried function, you could make propertyAccessor take two arguments, prop and obj, and you could constrain K to be keyof T. But that's not going to work. When you call propertyAccessor, you call it with only the prop argument of type K. And the compiler needs to infer K from that call, without knowing what you will do with the result. That is, it needs to know K before it can possibly know about T. So instead of constraining K to keyof T, you can only constrain it to some keylike type (in your case you already had string so we can use that).

So then K is essentially unconstrained except for being a string, and it returns a function which needs to be generic in T. We need to express that T[K] is a valid operation, but it's too late to say K extends keyof T. Instead we need to reverse the constraint: T extends Record<K, any>, using the Record<K, V> utility type to say that T has some property with key K.

That gives us this:

function propertyAccessor<K extends string>(prop: K):
    <T extends Record<K, any>>(obj: T) => T[K] {
    return (obj) => obj[prop]
}

Let's try it:

interface Dated {
    date: Date
}
const dated: Dated = { date: new Date() }

let goodAccess = propertyAccessor('date')(dated); // okay
// let goodAccess: Date

let badAccess = propertyAccessor('Helsinki')(dated) // error!
// ----------------------------------------> ~~~~~
// Property 'Helsinki' is missing in type 'Dated' but required in 
// type 'Record<"Helsinki", any>'.(2345)

Looks good. The correct call is accepted and the incorrect one is rejected.

Note where the error appears for badAccess. The call propertyAccessor('Helsinki') is fine by itself, as it has to be. The compiler doesn't try to anticipate that you are going to do something wrong with that function, or that you should have called it with a different argument to fix the mistake you'll make later. As far as the compiler is concerned, you are going to use that returned function to access the Helsinki property of some object. And since Dated does not have such a property, the error is reported on dated.

Playground link to code