Assert that optional properties in interface are not null in class at compile time

In Javascript I like to pass an options object to a constructor, and fill in any missing properties I expected with default values:

function foo(options) {
   if(options.a == undefined) {
      options.a = 1;
   }
   if(options.b == undefined) {
      options.b = 'hello';
   }
   this.options = options;
}

new foo({a: 10});

Trying to implement this pattern in Typescript, I have:

interface Options {
    a?: number;
    b?: string;
}

class Foo {
   options: Options;
   constructor(options: Options) {
      if(options.a == undefined) {
         options.a = 1;
      }
      if(options.b == undefined) {
         options.b = 'hello';
      }
      this.options = options;
   }
}

When I use options in the class later, I know that all the properties are defined. However, Typescript isn't aware of this, so this statement produces an error:

let a:Number = this.options.a; // Argument of type 'number | undefined' is not assignable to parameter of type number.

Additionally, I don't want to allow code in the class to assign a null or undefined value to the property later:

this.options.a = undefined; // should produce compiler error

Is there a way to define my types, so the properties of Options aren't nullable when used in the class without defining two Options interfaces?

For example, I know I could make another interface for internal use:

interface OptionsSafe {
    a: number;
    b: string;
}

// in Foo constructor
this.options = {
    a: a != undefined ? options.a! : 1,
    b: b != undefined ? options.b! : 'hello'
};

But then I need to define the properties of options in two separate interfaces, and make sure they're always in sync (this solution would be great if Typescript can generate both interfaces from one definition).

I also don't want to pass all the properties as individual, optional arguments, because (1) there can be dozens or more options and (2) The function arguments could drift from the Options interface, so I still have to keep two "interfaces" in sync.