How to use the optimal.object function in optimal

shape({ [singularName]: string().notEmpty() }),
        instance(contract, true),
      ], []));
    });

    const config = optimal(
      this.inheritFromArgs(this.parseAndExtend(configPath), args),
      {
        ...configBlueprint,
        ...pluginsBlueprint,
        debug: bool(),
        extends: array(string()),
        locale: string(),
        output: number(2).between(1, 3, true),
        // shape() requires a non-empty object
        settings: isEmpty(settingsBlueprint) ? object() : shape(settingsBlueprint),
        silent: bool(),
        theme: string('default').notEmpty(),
      },
      {
        file: configPath instanceof Path ? configPath.name() : '',
        name: 'ConfigLoader',
        unknown: true,
      },
    );

    return (config as unknown) as T;
  }

shape({ [singularName]: string().notEmpty() }),
        instance(contract as Constructor, true),
      ], []));
    });

    const config = optimal(
      this.inheritFromArgs(this.parseAndExtend(configPath), args),
      {
        ...configBlueprint,
        ...pluginsBlueprint,
        debug: bool(),
        extends: array(string()),
        locale: string(),
        output: number(2).between(1, 3, true),
        // shape() requires a non-empty object
        settings: isEmptyObject(settingsBlueprint) ? object() : shape(settingsBlueprint),
        silent: bool(),
        theme: string('default').notEmpty(),
      },
      {
        file: typeof configPath === 'string' ? path.basename(configPath) : '',
        name: 'ConfigLoader',
        unknown: true,
      },
    );

    return config as T;
  }

.match(APP_NAME_PATTERN),
        appPath: string()
          .required()
          .notEmpty(),
        argOptions: object(),
        configBlueprint: object(),
        configName: string().custom(value => {
          if (value && !value.match(CONFIG_NAME_PATTERN)) {
            throw new Error('Config file name must be camel case without extension.');
          }
        }),
        footer: string(),
        header: string(),
        root: string(process.cwd()),
        scoped: bool(),
        settingsBlueprint: object(),
        workspaceRoot: string(),
      },
      {
        name: this.constructor.name,
      },
    );

    this.appPath = Path.resolve(this.options.appPath);
    this.rootPath = Path.resolve(this.options.root);

    // Set environment variables
    env('DEBUG_GLOBAL_NAMESPACE', this.options.appName);

    // Core debugger, logger, and translator for the entire tool
    this.debug = createDebugger('core');

constructor(options: Options, attribute: string, config: Partial = {}) {
    super(options, attribute, config, false);

    // @ts-ignore
    this.config = optimal(
      this.config,
      {
        // @ts-ignore
        attributes: object(this.createUnionType(), null)
          .xor('reference')
          .notEmpty()
          .nullable(),
        nullable: bool(),
        optional: bool(),
        reference: string().xor('attributes'),
        type: string('shape').notEmpty(),
      },
      {
        name: 'ShapeDefinition',
        unknown: true,
      },
    );

    const { attributes } = this.config;

blueprint(predicates: Predicates) /* infer */ {
    // eslint-disable-next-line
    return {
      args: array(string()),
      dependencies: array(string()),
      env: object(string()),
      strategy: string(STRATEGY_NATIVE).oneOf([
        STRATEGY_NATIVE,
        STRATEGY_CREATE,
        STRATEGY_REFERENCE,
        STRATEGY_COPY,
        STRATEGY_NONE,
      ]),
    } as $FixMe;
  }

constructor(options: ToolOptions, argv: string[] = []) {
    super();

    this.argv = argv;
    this.options = optimal(
      options,
      {
        appName: string()
          .required()
          .notEmpty()
          .match(APP_NAME_PATTERN),
        appPath: string()
          .required()
          .notEmpty(),
        argOptions: object(),
        configBlueprint: object(),
        configName: string().custom(value => {
          if (value && !value.match(CONFIG_NAME_PATTERN)) {
            throw new Error('Config file name must be camel case without extension.');
          }
        }),
        footer: string(),
        header: string(),
        root: string(process.cwd()),
        scoped: bool(),
        settingsBlueprint: object(),
        workspaceRoot: string(),
      },
      {
        name: this.constructor.name,
      },
    );

constructor(options: ToolOptions, argv: string[] = []) {
    super();

    this.argv = argv;
    this.options = optimal(
      options,
      {
        appName: string()
          .required()
          .notEmpty()
          .match(APP_NAME_PATTERN),
        appPath: string()
          .required()
          .notEmpty(),
        argOptions: object(),
        configBlueprint: object(),
        configName: string().custom(value => {
          if (value && !value.match(CONFIG_NAME_PATTERN)) {
            throw new Error('Config file name must be camel case without extension.');
          }
        }),
        footer: string(),
        header: string(),
        root: string(process.cwd()),
        scoped: bool(),
        settingsBlueprint: object(),
        workspaceRoot: string(),
      },
      {
        name: this.constructor.name,
      },