How to avoid null/undefined check on JS/Typescript singleton with init function

I’m trying to find a pattern to avoid having to null/undefined check each literal props defined in an Object literal that is dynamically initiated only once at some point.
This object would serve as a singleton in a lifecycle of the application.

Is there a way to make this cleaner and avoid having to check and throw for each method that depends on the init to have happened? And also avoid ! operator on each prop once I know it is properly initiated?

I also want method2 to be able to be called before the init so that I can enqueue some things…
I guess I could switch my Object for a class and constructor (and define an instance as per singleton pattern) but the props for the constructor are needed from outside the class.
My method2 would also not be available until first constructed, unless I move it out of that class.

Any help appreciated.

interface StuffType {
  x?: string;
  y?: string;
  z?: string;
  fn?: () => void;
  isInit: boolean;
}

const _stuff: StuffType = {
  x: undefined,
  y: undefined,
  z: undefined,
  fn: undefined,
  isInit: false,
};

const isReady = () => _stuff.isInit;

const init = (x: string, y: string, z: string, fn: () => void) => {
  if(_stuff.isInit) return;
  _stuff.x = x;
  _stuff.y = y;
  _stuff.z = z;
  _stuff.fn = fn;
};

const method1 = () => {
  // depends on xyz, fn being defined
  if (!_stuff.isInit) throw new Error('not init');
  _stuff.fn!();
  _stuff.x!;
  _stuff.y!;
  _stuff.z!;
};

// All the following methods would depend on init being done
// would require check on init/throw error/bang operator on props
// const method3 = () =>
// const method4 = () =>
// const method5 = () =>
// const method6 = () =>

const method2 = () => {
  // does not depend on xyz, fn
};

export const Stuff = {
  init,
  isReady,
  method1,
  method2,
  //etc...
};

Stuff.method2(); // fine
Stuff.method1(); // throws here
Stuff.init('x', 'y', 'z', () => console.log('init'));
Stuff.method1(); // does not throw