In order to prevent users from accessing the constructor of Optional, it is recommended not to declare it as a class since the class serves as implementation details. Within the file optional.d.ts:

export interface Optional<T> {
    /* … only public members here … */
}

Within the file index.d.ts, you have the option to import and reexport Optional:

import { Optional } from './lib/optional';
export { Optional };
// …

Alternatively, you can directly define and export the type Optional within index.d.ts.

Subsequently, in another library:

import { ofNullable, Optional } from 'optional-js';
// …
const path: Optional<string> = ofNullable(this.props.match.params.path);

The issue was resolved by consolidating two files into a single class definition.

export default class Optional<T> {
  private readonly _value;
  private constructor(value?: T | null | undefined);

  /**
   * Returns an Optional describing the given value, if non-null, otherwise returns an empty Optional.
   *
   * @typeparam T the type of the value
   * @param value the possibly-null value to describe
   * @return an Optional with a present value if the specified value is non-null, otherwise an empty Optional
   */
  static ofNullable<T>(value: T | undefined | null): Optional<T>;

  /**
   * Returns an Optional describing the given non-null value.
   *
   * @typeparam T the type of the value
   * @param value the value to describe, which must be non-null
   * @return an Optional with the value present
   * @throws Error if value is null
   */
  static of<T>(value: T | null | undefined): Optional<T>;

  /**
   * Returns an empty Optional instance. No value is present for this Optional.
   *
   * @return an empty Optional
   */
  static empty(): Optional<null>;

  /**
   * If a value is present in this Optional, returns the value, otherwise throws an Error.
   *
   * @return the non-null value held by this Optional
   * @throws Error if the value is null;
   */
  get(): T | null | undefined;

  /**
   * Return true if there is a value present, otherwise false.
   *
   * @return true if there is a value present, otherwise false
   */
  isPresent(): boolean;

  /**
   * If a value is present, invoke the specified consumer with the value, otherwise do nothing.
   *
   * @param consumer function to be executed if a value is present
   */
  ifPresent(consumer: (value: T) => void): void;

  /**
   * If a value is present, and the value matches the given predicate, return an Optional describing the value,
   * otherwise return an empty Optional.
   *
   * @param predicate A predicate to apply to the value, if present
   * @return an Optional describing the value of this Optional if a value is present and the value matches the given
   * predicate, otherwise an empty Optional
   * @throws Error if the predicate is null
   */
  filter(predicate: (value: T) => boolean): Optional<T | null | undefined>;

  /**
   * If a value is present, apply the provided mapping function to it, and if the result is non-null,
   * return an Optional describing the result. Otherwise return an empty Optional.
   *
   * @typeparam U The type of the result of the mapping function
   * @param mapper a mapping function to apply to the value, if present.
   * @return an Optional describing the result of applying a mapping function to the value of this Optional,
   * if a value is present, otherwise an empty Optional
   * @throws Error if the mapping function is null
   */
  map<U>(mapper: (value: T) => U | undefined | null): Optional<U>;

  /**
   * If a value is present, apply the provided Optional-bearing mapping function to it, return that result,
   * otherwise return an empty Optional. This method is similar to map(Function), but the provided mapper is one whose
   * result is already an Optional, and if invoked, flatMap does not wrap it with an additional Optional.
   *
   * @typeparam U The type parameter to the Optional returned by the mapping function
   * @param mapper a mapping function to apply to the value, if present the mapping function
   * @return the result of applying an Optional-bearing mapping function to the value of this Optional,
   * if a value is present, otherwise an empty Optional
   * @throws Error if the mapping function is null or returns a null result
   */
  flatMap<U>(mapper: (value: T) => Optional<U> | undefined | null): Optional<U>;

  /**
   * If a value is present, returns the value, otherwise returns other.
   *
   * @param other the value to be returned, if no value is present. May be null.
   * @return the value, if present, otherwise other
   */
  orElse(other: T): T;

  /**
   * If a value is present, returns the value, otherwise returns the result produced by the supplying function.
   *
   * @param supplier the supplying function that produces a value to be returned
   * @return the value, if present, otherwise the result produced by the supplying function
   * @throws Error if no value is present and the supplying function is null
   */
  orElseGet(supplier: () => T): T;

  /**
   * If a value is present, returns the value, otherwise throws an exception produced by the exception supplying function.
   *
   * @param exceptionSupplier the supplying function that produces an exception to be thrown
   * @return the value, if present
   * @throws Error if no value is present and the exception supplying function is null
   */
  orElseThrow(exceptionSupplier: () => Error): T;

  /**
   * If a value is present, performs the given action with the value, otherwise performs the given empty-based action.
   *
   * @param action the action to be performed, if a value is present
   * @param emptyAction the empty-based action to be performed, if no value is present
   * @throws if a value is present and the given action is null, or no value is present and the given empty-based action is null.
   */
  ifPresentOrElse(action: (value: T) => void, emptyAction: () => void): void;

  /**
   * If a value is present, returns an Optional describing the value, otherwise returns an Optional produced by the supplying function.
   *
   * @param optionalSupplier the supplying function that produces an Optional to be returned
   * @return returns an Optional describing the value of this Optional, if a value is present,
   * otherwise an Optional produced by the supplying function.
   * @throws Error if the supplying function is null or produces a null result
   */
  or(optionalSupplier: () => Optional<T>): Optional<T>;
}

I labeled the constructor as private because you cannot instantiate the class since it is not exported. Is this considered a workaround?