declare namespace java {
    namespace nio {
        namespace file {
            // @ts-ignore
             class Paths extends java.lang.Object {
                /**
                 * Converts a path string, or a sequence of strings that when joined form
                 * a path string, to a {@code Path}. If {@code more} does not specify any
                 * elements then the value of the {@code first} parameter is the path string
                 * to convert. If {@code more} specifies one or more elements then each
                 * non-empty string, including {@code first}, is considered to be a sequence
                 * of name elements (see {@link Path}) and is joined to form a path string.
                 * The details as to how the Strings are joined is provider specific but
                 * typically they will be joined using the {@link FileSystem#getSeparator
                 * name-separator} as the separator. For example, if the name separator is
                 * "{@code /}" and {@code getPath("/foo","bar","gus")} is invoked, then the
                 * path string {@code "/foo/bar/gus"} is converted to a {@code Path}.
                 * A {@code Path} representing an empty path is returned if {@code first}
                 * is the empty string and {@code more} does not contain any non-empty
                 * strings.
                 * <p> The {@code Path} is obtained by invoking the {@link FileSystem#getPath
                 * getPath} method of the {@link FileSystems#getDefault default} {@link
                 * FileSystem}.
                 * <p> Note that while this method is very convenient, using it will imply
                 * an assumed reference to the default {@code FileSystem} and limit the
                 * utility of the calling code. Hence it should not be used in library code
                 * intended for flexible reuse. A more flexible alternative is to use an
                 * existing {@code Path} instance as an anchor, such as:
                 * <pre>
                 * Path dir = ...
                 * Path path = dir.resolve("file");
                 * </pre>
                 */
                // @ts-ignore
                public static get(first: string, more: string): java.nio.file.Path;
                /**
                 * Converts the given URI to a {@link Path} object.
                 * <p> This method iterates over the {@link FileSystemProvider#installedProviders()
                 * installed} providers to locate the provider that is identified by the
                 * URI {@link URI#getScheme scheme} of the given URI. URI schemes are
                 * compared without regard to case. If the provider is found then its {@link
                 * FileSystemProvider#getPath getPath} method is invoked to convert the
                 * URI.
                 * <p> In the case of the default provider, identified by the URI scheme
                 * "file", the given URI has a non-empty path component, and undefined query
                 * and fragment components. Whether the authority component may be present
                 * is platform specific. The returned {@code Path} is associated with the
                 * {@link FileSystems#getDefault default} file system.
                 * <p> The default provider provides a similar <em>round-trip</em> guarantee
                 * to the {@link java.io.File} class. For a given {@code Path} <i>p</i> it
                 * is guaranteed that
                 * <blockquote><tt>
                 * Paths.get(</tt><i>p</i><tt>.{@link Path#toUri() toUri}()).equals(</tt>
                 * <i>p</i><tt>.{@link Path#toAbsolutePath() toAbsolutePath}())</tt>
                 * </blockquote>
                 * so long as the original {@code Path}, the {@code URI}, and the new {@code
                 * Path} are all created in (possibly different invocations of) the same
                 * Java virtual machine. Whether other providers make any guarantees is
                 * provider specific and therefore unspecified.
                 */
                // @ts-ignore
                public static get(uri: java.net.URI): java.nio.file.Path;
            }
        }
    }
}
