Is the wrapping of Vinyl file to class is Valid?

[TokugawaTakeshi]

Below recipe from the Vinyl documentation is a valid JavaScript, but not valid TypeScript:

var Vinyl = require('vinyl');

var builtInProps = ['foo', '_foo'];

class SuperFile extends Vinyl {
  constructor(options) {
    super(options);
    this._foo = 'example internal read-only value';
  }

  get foo() {
    return this._foo;
  }

  static isCustomProp(name) {
    return super.isCustomProp(name) && builtInProps.indexOf(name) === -1;
  }
}

In the TypeScript, extends Vinyl causes TS2510: Base constructors must all have the same return type. error.
This problem has been explained in How to access to interface or type alias which has not been explicitly exported in TypeScript type definitions? topic in StackOverflow.

Well, I understand if you want to use JavaScript and basic language for the development and cannot require from you the full migration to TypeScript. What I want in this discussion is to confirm one thing - it is safe to create the class extending the Vinyl file like below?

export default class MarkupVinylFile extends VinylFile {

  public readonly sourceAbsolutePath: string;
  public readonly outputDirectoryAbsolutePath: string;
  public readonly markupProcessingSettings: MarkupProcessingSettings__Normalized.EntryPointsGroup;

  public constructor(
    initialFile: VinylFile, relevantMarkupProcessingSettings: MarkupProcessingSettings__Normalized.EntryPointsGroup
  ) {

    super({
      base: initialFile.base,
      path: initialFile.path,
      contents: initialFile.contents
    });

    this.sourceAbsolutePath = /* initializing of all fields. */
  }
}

I tried to avoid the routines like creating of builtInProps variable and adding of isCustomProp method from the example from the Vinyl documentation, so I have not passed the whole initialFile to the constructor of the superclass.

Well, the above class is still invalid TypeScript, but what I tried to confirm for now is does this class have some undesirable side effects.

This is the end of the question itself.
If you want to know my motivation, I'll explain it below.

---

First, if to use the class, will be too easy to filter the subtypes of Vinyl by file instanceof MarkupVinylFile.
The creating of the TypeGuard like

function isMarkupVinylFile(vinylFile: Vinyl): vinylFile is MarkupVinylFile {
   
   if (typeof vinylFile.sourceAbsolutePath !== "string" || vinylFile.sourceAbsolutePath.length === 0) {
     return false;
   }

   if (typeof vinylFile.outputDirectoryAbsolutePath !== "string" || vinylFile.outputDirectoryAbsolutePath.length === 0) {
     return false;
   }

   // ...

   return true;
}

is too much routines.

Second, both adding of new properties to Vinyl file and accessing to them is not type-safe:

import Gulp from "gulp";
import type VinylFile from "vinyl";
import gulpIntercept from "gulp-intercept";

Gulp.src(entryPointsSourceFilesAbsolutePaths).
    pipe(gulpIntercept((fileInInitialState: VinylFile): MarkupProcessor.MarkupVinylFile {

      const markupEntryPointsGroupSettingsActualForCurrentFile: MarkupProcessingSettings__Normalized.EntryPointsGroup =
          this.markupProcessingConfigRepresentative.
            getEntryPointsGroupSettingsRelevantForSpecifiedSourceFileAbsolutePath(fileInInitialState.path);

       // The mistyping in `processingSettings` will not be detected by TypeScript
       fileInInitialState.processingSettings = markupEntryPointsGroupSettingsActualForCurrentFile;

      /* [ Theory ] The value of 'path' could change during file processing. */
      // The mistyping in `sourceAbsolutePath ` will not be detected by TypeScript
      fileInInitialState.sourceAbsolutePath = ImprovedPath.replacePathSeparatorsToForwardSlashes(fileInInitialState.path);

      // The mistyping in `outputDirectoryAbsolutePath ` will not be detected by TypeScript
      fileInInitialState.outputDirectoryAbsolutePath = MarkupProcessingSettingsRepresentative.
        computeRelevantOutputDirectoryAbsolutePathForTargetSourceFile(
          fileInInitialState.path, markupEntryPointsGroupSettingsActualForCurrentFile
        );

    // The usage of `as` is the bad practice and should be evaded as possible
    return fileInInitialState as MarkupProcessor.MarkupVinylFile;
  })).
  // ...
  pipe(
    Gulp.dest((targetFileInFinalState: VinylFile): string =>
      // The usage of `as` is the bad practice and should be evaded as possible
      (targetFileInFinalState as MarkupProcessor.MarkupVinylFile).outputDirectoryAbsolutePath)
  );

The creating of the class as MarkupVinylFile fully solves this problem.