How to use the ngrx-forms.unbox function in ngrx-forms

export function requiredFalse | null | undefined>(value: T): ValidationErrors {
  value = unbox(value) as boolean | null | undefined as T;

  // tslint:disable-next-line:strict-type-predicates
  if (value === null || value === undefined) {
    return {};
  }

  if (!value) {
    return {};
  }

  return {
    required: {
      actual: value,
    },
  };
}

it('should return errors with comparand and actual properties', () => {
    const comparand = 1;
    const actual = box(2);
    expect(lessThanOrEqualTo(comparand)(actual)).toEqual({
      lessThanOrEqualTo: {
        comparand,
        actual: unbox(actual),
      },
    });
  });

it('should return an error for boxed true', () => {
    const value = box(true);
    expect(requiredFalse(value)).toEqual({
      required: {
        actual: unbox(value),
      },
    });
  });

it('should return errors with pattern and actual properties for boxed values', () => {
    const value = box('abc');
    expect(email(value)).toEqual({
      email: {
        pattern: NGRX_FORMS_EMAIL_VALIDATION_REGEXP.toString(),
        actual: unbox(value),
      },
    });
  });

it('should return errors with pattern and actual properties for boxed value', () => {
    const patternValue = /a/g;
    const actualValue = box('b');
    expect(pattern(patternValue)(actualValue)).toEqual({
      pattern: {
        pattern: patternValue.toString(),
        actual: unbox(actualValue),
      },
    });
  });

it('should return an error for boxed false', () => {
    const value = box(false);
    expect(requiredTrue(value)).toEqual({
      required: {
        actual: unbox(value),
      },
    });
  });

it('should return errors with maxLength, value, and actualLength properties for boxed array value', () => {
    const maxLengthParam = 2;
    const value = box(['a', 'b', 'c']);
    expect(maxLength(maxLengthParam)(value)).toEqual({
      maxLength: {
        maxLength: maxLengthParam,
        value: unbox(value),
        actualLength: unbox(value).length,
      },
    });
  });

return  | null | undefined>(value: T): ValidationErrors => {
    value = unbox(value) as string | null | undefined as T;

    if (value === null || value === undefined || (value as string).length === 0) {
      return {};
    }

    if (patternParam.test(value as string)) {
      return {};
    }

    return {
      pattern: {
        pattern: patternParam.toString(),
        actual: value as string,
      },
    };
  };

return  | null | undefined>(value: T): ValidationErrors => {
    value = unbox(value) as number | null | undefined as T;

    if (value === null || value === undefined) {
      return {};
    }

    if (value > comparand) {
      return {};
    }

    return {
      greaterThan: {
        comparand,
        actual: value as number,
      },
    };
  };

return  | null | undefined>(value: T): ValidationErrors => {
    value = unbox(value) as number | null | undefined as T;

    if (value === null || value === undefined) {
      return {};
    }

    if (value >= comparand) {
      return {};
    }

    return {
      greaterThanOrEqualTo: {
        comparand,
        actual: value as number,
      },
    };
  };