Empty string, undefined, null, ...

To check for a truthy value:

if (strValue) {
    // strValue was non-empty string, true, 42, Infinity, [], ...
}

To check for a falsy value:

if (!strValue) {
    // strValue was empty string, false, 0, null, undefined, ...
}

Empty string (only!)

To check for exactly an empty string, compare for strict equality against "" using the === operator:

if (strValue === "") {
    // strValue was empty string
}

To check for not an empty string strictly, use the !== operator:

if (strValue !== "") {
    // strValue was not an empty string
}

I believe this is as close as you're going to get only using the typing system (rather than having a 'nonEmptyString' class)

type nonEmptyString = never; // Cannot be implicitly cast to
function isNonEmptyString(str: string): str is nonEmptyString {
    return str && str.length > 0; // Or any other logic, removing whitespace, etc.
}

Testing it:

let fn = function(a: nonEmptyString) {

}

let someStr = '';
if (isNonEmptyString(someStr)) {
    fn(someStr); // Valid
} else {
    fn(someStr); // Compile error
}

Unfortunately, you end up with warts since nonEmptyString is never. Which means you need to explicitly cast nonEmptyString back to string.

let fn = function(a: nonEmptyString) {
    let len = a.length; // Invalid
    let len2 = (<string>a).length; // Valid
    let str = a + 'something else'; // Valid (str is now typed as string)
}

One possible resolution is:

type nonEmptyString = string & { __nonEmptyStr: never };

Which alleviates the problem of having to explicitly cast back to a string (all three tests above are valid), but does pollute the type with __nonEmptyStr (which will be undefined if referenced).

You can simply use typeof. It will check undefined, null, 0 and "" also.

if(typeof RetailPrice!='undefined' && RetailPrice){
   return this.RetailPrice;
}