deno.d.ts

declare module 'deno' {
  export = deno;
}

declare namespace deno {
  
  const bytesSymbol: unique symbol;
  export class DenoBlob implements domTypes.Blob {
      private readonly [bytesSymbol];
      readonly size: number;
      readonly type: string;
      constructor(blobParts?: domTypes.BlobPart[], options?: domTypes.BlobPropertyBag);
      slice(start?: number, end?: number, contentType?: string): DenoBlob;
  }
  
  export class Buffer implements Reader, Writer {
      private buf;
      private off;
      constructor(ab?: ArrayBuffer);
      bytes(): Uint8Array;
      toString(): string;
      empty(): boolean;
      readonly length: number;
      readonly capacity: number;
      truncate(n: number): void;
      reset(): void;
      private _tryGrowByReslice;
      private _reslice;
      read(p: ArrayBufferView): Promise<ReadResult>;
      write(p: ArrayBufferView): Promise<number>;
      private _grow;
      grow(n: number): void;
      readFrom(r: Reader): Promise<number>;
  }
  
  export function chmodSync(path: string, mode: number): void;
  export function chmod(path: string, mode: number): Promise<void>;
  
  export type AmdFactory = (...args: any[]) => object | void;
  export type AmdDefine = (deps: ModuleSpecifier[], factory: AmdFactory) => void;
  declare type ContainingFile = string;
  declare type ModuleFileName = string;
  declare type ModuleId = string;
  declare type ModuleSpecifier = string;
  declare type OutputCode = string;
  declare type SourceCode = string;
  declare type SourceMap = string;
  export class ModuleMetaData implements ts.IScriptSnapshot {
      readonly moduleId: ModuleId;
      readonly fileName: ModuleFileName;
      readonly mediaType: MediaType;
      readonly sourceCode: SourceCode;
      outputCode: OutputCode;
      sourceMap: SourceMap;
      deps?: ModuleFileName[];
      exports: {};
      factory?: AmdFactory;
      gatheringDeps: boolean;
      hasRun: boolean;
      scriptVersion: string;
      constructor(moduleId: ModuleId, fileName: ModuleFileName, mediaType: MediaType, sourceCode?: SourceCode, outputCode?: OutputCode, sourceMap?: SourceMap);
      getText(start: number, end: number): string;
      getLength(): number;
      getChangeRange(): undefined;
  }
  export function jsonAmdTemplate(jsonString: string, sourceFileName: string): OutputCode;
  export class DenoCompiler implements ts.LanguageServiceHost, ts.FormatDiagnosticsHost {
      private readonly _fileNamesMap;
      private _globalEval;
      private _log;
      private readonly _moduleMetaDataMap;
      private readonly _options;
      private _os;
      private _runQueue;
      private _scriptFileNames;
      private _service;
      private _ts;
      private _window;
      recompile: boolean;
      private _drainRunQueue;
      private _gatherDependencies;
      private _getFactoryArguments;
      private _getModuleMetaData;
      private _makeDefine;
      private _makeLocalRequire;
      private _resolveFileName;
      private _setFileName;
      private _setupSourceMaps;
      private constructor();
      compile(moduleMetaData: ModuleMetaData): OutputCode;
      getModuleDependencies(moduleSpecifier: ModuleSpecifier, containingFile: ContainingFile): ModuleFileName[];
      resolveModule(moduleSpecifier: ModuleSpecifier, containingFile: ContainingFile): ModuleMetaData;
      run(moduleSpecifier: ModuleSpecifier, containingFile: ContainingFile): ModuleMetaData;
      getCanonicalFileName(fileName: string): string;
      getCompilationSettings(): ts.CompilerOptions;
      getNewLine(): string;
      getScriptFileNames(): string[];
      getScriptKind(fileName: ModuleFileName): ts.ScriptKind;
      getScriptVersion(fileName: ModuleFileName): string;
      getScriptSnapshot(fileName: ModuleFileName): ts.IScriptSnapshot | undefined;
      getCurrentDirectory(): string;
      getDefaultLibFileName(): string;
      useCaseSensitiveFileNames(): boolean;
      readFile(path: string): string | undefined;
      fileExists(fileName: string): boolean;
      resolveModuleNames(moduleNames: ModuleSpecifier[], containingFile: ContainingFile): Array<ts.ResolvedModuleFull | ts.ResolvedModule>;
      private static _builtins;
      private static _instance;
      static instance(): DenoCompiler;
  }
  
  export class Console {
      private printFunc;
      log: (...args: any[]) => void;
      debug: (...args: any[]) => void;
      info: (...args: any[]) => void;
      dir: (obj: any, options?: Partial<{
          showHidden: boolean;
          depth: number;
          colors: boolean;
      }>) => void;
      warn: (...args: any[]) => void;
      error: (...args: any[]) => void;
      assert: (condition: boolean, ...args: any[]) => void;
  }
  
  export function copyFileSync(from: string, to: string): void;
  export function copyFile(from: string, to: string): Promise<void>;
  
  /// <amd-module name="deno" />
  
  export const args: string[];
  
  export function cwd(): string;
  export function chdir(directory: string): void;
  
  export function setFireTimersCallback(fn: () => void): void;
  export function handleAsyncMsgFromRust(ui8: Uint8Array): void;
  
  /*! ****************************************************************************
  Copyright (c) Microsoft Corporation. All rights reserved.
  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at http://www.apache.org/licenses/LICENSE-2.0
  
  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
  ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  MERCHANTABLITY OR NON-INFRINGEMENT.
  
  See the Apache Version 2.0 License for specific language governing permissions
  and limitations under the License.
  *******************************************************************************/
  export type HeadersInit = Headers | Array<[string, string]> | Record<string, string>;
  export type URLSearchParamsInit = string | string[][] | Record<string, string>;
  declare type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream | string;
  export type RequestInfo = Request | string;
  declare type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin-only" | "origin-when-cross-origin" | "unsafe-url";
  export type BlobPart = BufferSource | Blob | string;
  export type FormDataEntryValue = File | string;
  export type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
  export interface DomIterable<K, V> {
      keys(): IterableIterator<K>;
      values(): IterableIterator<V>;
      entries(): IterableIterator<[K, V]>;
      [Symbol.iterator](): IterableIterator<[K, V]>;
      forEach(callback: (value: V, key: K, parent: this) => void, thisArg?: any): void;
  }
  interface Element {
  }
  export interface HTMLFormElement {
  }
  declare type EndingType = "transparent" | "native";
  export interface BlobPropertyBag {
      type?: string;
      ending?: EndingType;
  }
  interface AbortSignalEventMap {
      abort: ProgressEvent;
  }
  interface EventTarget {
      addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
      dispatchEvent(evt: Event): boolean;
      removeEventListener(type: string, listener?: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
  }
  export interface ProgressEventInit extends EventInit {
      lengthComputable?: boolean;
      loaded?: number;
      total?: number;
  }
  export interface URLSearchParams {
      append(name: string, value: string): void;
      delete(name: string): void;
      get(name: string): string | null;
      getAll(name: string): string[];
      has(name: string): boolean;
      set(name: string, value: string): void;
      sort(): void;
      toString(): string;
      forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
  }
  interface EventListener {
      (evt: Event): void;
  }
  interface EventInit {
      bubbles?: boolean;
      cancelable?: boolean;
      composed?: boolean;
  }
  interface Event {
      readonly bubbles: boolean;
      cancelBubble: boolean;
      readonly cancelable: boolean;
      readonly composed: boolean;
      readonly currentTarget: EventTarget | null;
      readonly defaultPrevented: boolean;
      readonly eventPhase: number;
      readonly isTrusted: boolean;
      returnValue: boolean;
      readonly srcElement: Element | null;
      readonly target: EventTarget | null;
      readonly timeStamp: number;
      readonly type: string;
      deepPath(): EventTarget[];
      initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
      preventDefault(): void;
      stopImmediatePropagation(): void;
      stopPropagation(): void;
      readonly AT_TARGET: number;
      readonly BUBBLING_PHASE: number;
      readonly CAPTURING_PHASE: number;
      readonly NONE: number;
  }
  export interface File extends Blob {
      readonly lastModified: number;
      readonly name: string;
  }
  export interface FilePropertyBag extends BlobPropertyBag {
      lastModified?: number;
  }
  interface ProgressEvent extends Event {
      readonly lengthComputable: boolean;
      readonly loaded: number;
      readonly total: number;
  }
  interface EventListenerOptions {
      capture?: boolean;
  }
  interface AddEventListenerOptions extends EventListenerOptions {
      once?: boolean;
      passive?: boolean;
  }
  interface AbortSignal extends EventTarget {
      readonly aborted: boolean;
      onabort: ((this: AbortSignal, ev: ProgressEvent) => any) | null;
      addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
      addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
      removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
      removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
  }
  interface ReadableStream {
      readonly locked: boolean;
      cancel(): Promise<void>;
      getReader(): ReadableStreamReader;
  }
  interface EventListenerObject {
      handleEvent(evt: Event): void;
  }
  interface ReadableStreamReader {
      cancel(): Promise<void>;
      read(): Promise<any>;
      releaseLock(): void;
  }
  export interface FormData extends DomIterable<string, FormDataEntryValue> {
      append(name: string, value: string | Blob, fileName?: string): void;
      delete(name: string): void;
      get(name: string): FormDataEntryValue | null;
      getAll(name: string): FormDataEntryValue[];
      has(name: string): boolean;
      set(name: string, value: string | Blob, fileName?: string): void;
  }
  export interface FormDataConstructor {
      new (): FormData;
      prototype: FormData;
  }
  export interface Blob {
      readonly size: number;
      readonly type: string;
      slice(start?: number, end?: number, contentType?: string): Blob;
  }
  interface Body {
      readonly body: ReadableStream | null;
      readonly bodyUsed: boolean;
      arrayBuffer(): Promise<ArrayBuffer>;
      blob(): Promise<Blob>;
      formData(): Promise<FormData>;
      json(): Promise<any>;
      text(): Promise<string>;
  }
  export interface Headers extends DomIterable<string, string> {
      append(name: string, value: string): void;
      delete(name: string): void;
      entries(): IterableIterator<[string, string]>;
      get(name: string): string | null;
      has(name: string): boolean;
      keys(): IterableIterator<string>;
      set(name: string, value: string): void;
      values(): IterableIterator<string>;
      forEach(callbackfn: (value: string, key: string, parent: this) => void, thisArg?: any): void;
      [Symbol.iterator](): IterableIterator<[string, string]>;
  }
  export interface HeadersConstructor {
      new (init?: HeadersInit): Headers;
      prototype: Headers;
  }
  declare type RequestCache = "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached";
  declare type RequestCredentials = "omit" | "same-origin" | "include";
  declare type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
  declare type RequestMode = "navigate" | "same-origin" | "no-cors" | "cors";
  declare type RequestRedirect = "follow" | "error" | "manual";
  declare type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
  export interface RequestInit {
      body?: BodyInit | null;
      cache?: RequestCache;
      credentials?: RequestCredentials;
      headers?: HeadersInit;
      integrity?: string;
      keepalive?: boolean;
      method?: string;
      mode?: RequestMode;
      redirect?: RequestRedirect;
      referrer?: string;
      referrerPolicy?: ReferrerPolicy;
      signal?: AbortSignal | null;
      window?: any;
  }
  export interface ResponseInit {
      headers?: HeadersInit;
      status?: number;
      statusText?: string;
  }
  export interface Request extends Body {
      readonly cache: RequestCache;
      readonly credentials: RequestCredentials;
      readonly destination: RequestDestination;
      readonly headers: Headers;
      readonly integrity: string;
      readonly isHistoryNavigation: boolean;
      readonly isReloadNavigation: boolean;
      readonly keepalive: boolean;
      readonly method: string;
      readonly mode: RequestMode;
      readonly redirect: RequestRedirect;
      readonly referrer: string;
      readonly referrerPolicy: ReferrerPolicy;
      readonly signal: AbortSignal;
      readonly url: string;
      clone(): Request;
  }
  export interface Response extends Body {
      readonly headers: Headers;
      readonly ok: boolean;
      readonly redirected: boolean;
      readonly status: number;
      readonly statusText: string;
      readonly trailer: Promise<Headers>;
      readonly type: ResponseType;
      readonly url: string;
      clone(): Response;
  }
  
  export class DenoError<T extends ErrorKind> extends Error {
      readonly kind: T;
      constructor(kind: T, msg: string);
  }
  
  export function fetch(input?: domTypes.Request | string, init?: domTypes.RequestInit): Promise<domTypes.Response>;
  
  export class DenoFile extends blob.DenoBlob implements domTypes.File {
      lastModified: number;
      name: string;
      constructor(fileBits: domTypes.BlobPart[], fileName: string, options?: domTypes.FilePropertyBag);
  }
  
  export interface FileInfo {
      len: number;
      modified: number | null;
      accessed: number | null;
      created: number | null;
      mode: number | null;
      name: string | null;
      path: string | null;
      isFile(): boolean;
      isDirectory(): boolean;
      isSymlink(): boolean;
  }
  
  export class File implements Reader, Writer, Closer {
      readonly rid: number;
      constructor(rid: number);
      write(p: ArrayBufferView): Promise<number>;
      read(p: ArrayBufferView): Promise<ReadResult>;
      close(): void;
  }
  export const stdin: File;
  export const stdout: File;
  export const stderr: File;
  export type OpenMode = "r" | "w" | "w+" | "x";
  export function create(filename: string): Promise<File>;
  export function open(filename: string, mode?: OpenMode): Promise<File>;
  export function read(rid: number, p: ArrayBufferView): Promise<ReadResult>;
  export function write(rid: number, p: ArrayBufferView): Promise<number>;
  export function close(rid: number): void;
  
  export type Offset = flatbuffers.Offset;
  export class ByteBuffer extends flatbuffers.ByteBuffer {
  }
  export interface Builder extends flatbuffers.Builder {
      inUse: boolean;
  }
  export function createBuilder(): Builder;
  
  const dataSymbol: unique symbol;
  class FormDataBase {
      private [dataSymbol];
      append(name: string, value: string): void;
      append(name: string, value: blob.DenoBlob, filename?: string): void;
      delete(name: string): void;
      getAll(name: string): domTypes.FormDataEntryValue[];
      get(name: string): domTypes.FormDataEntryValue | null;
      has(name: string): boolean;
      set(name: string, value: string): void;
      set(name: string, value: blob.DenoBlob, filename?: string): void;
  }
  export const FormData: typeof FormDataBase & (new (...args: any[]) => domTypes.DomIterable<string, domTypes.FormDataEntryValue>);
  
  declare global {
      const console: console_.Console;
      const setTimeout: typeof timers.setTimeout;
      const TextEncoder: typeof textEncoding.TextEncoder;
  }
  export const window: any;
  
  export interface ReadResult {
      nread: number;
      eof: boolean;
  }
  export interface Reader {
      read(p: ArrayBufferView): Promise<ReadResult>;
  }
  export interface Writer {
      write(p: ArrayBufferView): Promise<number>;
  }
  export interface Closer {
      close(): void;
  }
  export interface Seeker {
      seek(offset: number, whence: number): Promise<void>;
  }
  export interface ReaderCloser extends Reader, Closer {
  }
  export interface WriteCloser extends Writer, Closer {
  }
  export interface ReadSeeker extends Reader, Seeker {
  }
  export interface WriteSeeker extends Writer, Seeker {
  }
  export interface ReadWriteCloser extends Reader, Writer, Closer {
  }
  export interface ReadWriteSeeker extends Reader, Writer, Seeker {
  }
  export function copy(dst: Writer, src: Reader): Promise<number>;
  export function toAsyncIterator(r: Reader): AsyncIterableIterator<ArrayBufferView>;
  
  declare type MessageCallback = (msg: Uint8Array) => void;
  export type PromiseRejectEvent = "RejectWithNoHandler" | "HandlerAddedAfterReject" | "ResolveAfterResolved" | "RejectAfterResolved";
  interface Libdeno {
      recv(cb: MessageCallback): void;
      send(control: ArrayBufferView, data?: ArrayBufferView): null | Uint8Array;
      print(x: string, isErr?: boolean): void;
      shared: ArrayBuffer;
      setGlobalErrorHandler: (handler: (message: string, source: string, line: number, col: number, error: Error) => void) => void;
      setPromiseRejectHandler: (handler: (error: Error | string, event: PromiseRejectEvent, promise: Promise<any>) => void) => void;
      setPromiseErrorExaminer: (handler: () => boolean) => void;
      mainSource: string;
      mainSourceMap: RawSourceMap;
  }
  export const libdeno: Libdeno;
  
  export interface MakeTempDirOptions {
      dir?: string;
      prefix?: string;
      suffix?: string;
  }
  export function makeTempDirSync(options?: MakeTempDirOptions): string;
  export function makeTempDir(options?: MakeTempDirOptions): Promise<string>;
  
  interface Metrics {
      opsDispatched: number;
      opsCompleted: number;
      bytesSentControl: number;
      bytesSentData: number;
      bytesReceived: number;
  }
  export function metrics(): Metrics;
  
  export function mkdirSync(path: string, mode?: number): void;
  export function mkdir(path: string, mode?: number): Promise<void>;
  
  export type Network = "tcp";
  export type Addr = string;
  export interface Listener {
      accept(): Promise<Conn>;
      close(): void;
      addr(): Addr;
  }
  export interface Conn extends Reader, Writer, Closer {
      localAddr: string;
      remoteAddr: string;
      closeRead(): void;
      closeWrite(): void;
  }
  export function listen(network: Network, address: string): Listener;
  export function dial(network: Network, address: string): Promise<Conn>;
  export function connect(network: Network, address: string): Promise<Conn>;
  
  export function exit(exitCode?: number): never;
  export function env(): {
      [index: string]: string;
  };
  
  export interface Platform {
      arch: "x64";
      os: "mac" | "win" | "linux";
  }
  export const platform: Platform;
  
  export function readDirSync(path: string): FileInfo[];
  export function readDir(path: string): Promise<FileInfo[]>;
  
  export function readFileSync(filename: string): Uint8Array;
  export function readFile(filename: string): Promise<Uint8Array>;
  
  export function readlinkSync(name: string): string;
  export function readlink(name: string): Promise<string>;
  
  export function removeSync(path: string): void;
  export function remove(path: string): Promise<void>;
  export function removeAllSync(path: string): void;
  export function removeAll(path: string): Promise<void>;
  
  export function renameSync(oldpath: string, newpath: string): void;
  export function rename(oldpath: string, newpath: string): Promise<void>;
  
  export function resources(): {
      [key: number]: string;
  };
  
  export function lstat(filename: string): Promise<FileInfo>;
  export function lstatSync(filename: string): FileInfo;
  export function stat(filename: string): Promise<FileInfo>;
  export function statSync(filename: string): FileInfo;
  
  export function symlinkSync(oldname: string, newname: string, type?: string): void;
  export function symlink(oldname: string, newname: string, type?: string): Promise<void>;
  
  export function atob(s: string): string;
  export function btoa(s: string): string;
  declare global {
      type BufferSource = ArrayBufferView | ArrayBuffer;
      interface TextDecodeOptions {
          stream?: boolean;
      }
      interface TextDecoderOptions {
          fatal?: boolean;
          ignoreBOM?: boolean;
      }
      interface TextDecoder {
          readonly encoding: string;
          readonly fatal: boolean;
          readonly ignoreBOM: boolean;
          decode(input?: BufferSource, options?: TextDecodeOptions): string;
      }
  }
  
  export function setTimeout<Args extends Array<unknown>>(cb: (...args: Args) => void, delay: number, ...args: Args): number;
  export function setInterval<Args extends Array<unknown>>(cb: (...args: Args) => void, delay: number, ...args: Args): number;
  export function clearTimer(id: number): void;
  
  export function truncateSync(name: string, len?: number): void;
  export function truncate(name: string, len?: number): Promise<void>;
  
  export type TypedArray = Uint8Array | Float32Array | Int32Array;
  export interface CallSite {
      getThis(): any;
      getTypeName(): string | null;
      getFunction(): Function | undefined;
      getFunctionName(): string | null;
      getMethodName(): string | null;
      getFileName(): string | null;
      getScriptNameOrSourceURL(): string;
      getLineNumber(): number | null;
      getColumnNumber(): number | null;
      getEvalOrigin(): string | undefined;
      isToplevel(): boolean;
      isEval(): boolean;
      isNative(): boolean;
      isConstructor(): boolean;
  }
  export interface StartOfSourceMap {
      file?: string;
      sourceRoot?: string;
  }
  export interface RawSourceMap extends StartOfSourceMap {
      version: string;
      sources: string[];
      names: string[];
      sourcesContent?: string[];
      mappings: string;
  }
  declare global {
      interface ErrorConstructor {
          captureStackTrace(targetObject: object, constructorOpt?: Function): void;
          prepareStackTrace?: (err: Error, stackTraces: CallSite[]) => any;
          stackTraceLimit: number;
      }
  }
  
  export class URLSearchParams {
      private params;
      constructor(init?: string | string[][] | Record<string, string>);
      append(name: string, value: string): void;
      delete(name: string): void;
      getAll(name: string): string[];
      get(name: string): string | null;
      has(name: string): boolean;
      set(name: string, value: string): void;
      sort(): void;
      forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
      keys(): Iterable<string>;
      values(): Iterable<string>;
      entries(): Iterable<[string, string]>;
      [Symbol.iterator](): Iterable<[string, string]>;
      toString(): string;
  }
  
  export function writeFileSync(filename: string, data: Uint8Array, perm?: number): void;
  export function writeFile(filename: string, data: Uint8Array, perm?: number): Promise<void>;
  
  declare type Constructor<T = {}> = new (...args: any[]) => T;
  export function DomIterableMixin<K, V, TBase extends Constructor>(Base: TBase, dataSymbol: symbol): TBase & Constructor<DomIterable<K, V>>;
  
  export enum Any {
      NONE = 0,
      Start = 1,
      StartRes = 2,
      CodeFetch = 3,
      CodeFetchRes = 4,
      CodeCache = 5,
      SetTimeout = 6,
      Exit = 7,
      Environ = 8,
      EnvironRes = 9,
      Fetch = 10,
      FetchRes = 11,
      MakeTempDir = 12,
      MakeTempDirRes = 13,
      Mkdir = 14,
      Chmod = 15,
      Remove = 16,
      ReadFile = 17,
      ReadFileRes = 18,
      ReadDir = 19,
      ReadDirRes = 20,
      WriteFile = 21,
      CopyFile = 22,
      Rename = 23,
      Readlink = 24,
      ReadlinkRes = 25,
      Resources = 26,
      ResourcesRes = 27,
      Symlink = 28,
      Stat = 29,
      StatRes = 30,
      SetEnv = 31,
      Truncate = 32,
      Open = 33,
      OpenRes = 34,
      Read = 35,
      ReadRes = 36,
      Write = 37,
      WriteRes = 38,
      Close = 39,
      Shutdown = 40,
      Listen = 41,
      ListenRes = 42,
      Accept = 43,
      Dial = 44,
      NewConn = 45,
      Chdir = 46,
      Cwd = 47,
      CwdRes = 48,
      Metrics = 49,
      MetricsRes = 50
  }
  export enum ErrorKind {
      NoError = 0,
      NotFound = 1,
      PermissionDenied = 2,
      ConnectionRefused = 3,
      ConnectionReset = 4,
      ConnectionAborted = 5,
      NotConnected = 6,
      AddrInUse = 7,
      AddrNotAvailable = 8,
      BrokenPipe = 9,
      AlreadyExists = 10,
      WouldBlock = 11,
      InvalidInput = 12,
      InvalidData = 13,
      TimedOut = 14,
      Interrupted = 15,
      WriteZero = 16,
      Other = 17,
      UnexpectedEof = 18,
      BadResource = 19,
      EmptyHost = 20,
      IdnaError = 21,
      InvalidPort = 22,
      InvalidIpv4Address = 23,
      InvalidIpv6Address = 24,
      InvalidDomainCharacter = 25,
      RelativeUrlWithoutBase = 26,
      RelativeUrlWithCannotBeABaseBase = 27,
      SetHostOnCannotBeABaseUrl = 28,
      Overflow = 29,
      HttpUser = 30,
      HttpClosed = 31,
      HttpCanceled = 32,
      HttpParse = 33,
      HttpOther = 34
  }
  export enum MediaType {
      JavaScript = 0,
      TypeScript = 1,
      Json = 2,
      Unknown = 3
  }
  export class Cwd {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Cwd;
      static getRootAsCwd(bb: flatbuffers.ByteBuffer, obj?: Cwd): Cwd;
      static startCwd(builder: flatbuffers.Builder): void;
      static endCwd(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class CwdRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): CwdRes;
      static getRootAsCwdRes(bb: flatbuffers.ByteBuffer, obj?: CwdRes): CwdRes;
      cwd(): string | null;
      cwd(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startCwdRes(builder: flatbuffers.Builder): void;
      static addCwd(builder: flatbuffers.Builder, cwdOffset: flatbuffers.Offset): void;
      static endCwdRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Base {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Base;
      static getRootAsBase(bb: flatbuffers.ByteBuffer, obj?: Base): Base;
      cmdId(): number;
      mutate_cmd_id(value: number): boolean;
      sync(): boolean;
      mutate_sync(value: boolean): boolean;
      errorKind(): ErrorKind;
      mutate_error_kind(value: ErrorKind): boolean;
      error(): string | null;
      error(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      innerType(): Any;
      mutate_inner_type(value: Any): boolean;
      inner<T extends flatbuffers.Table>(obj: T): T | null;
      static startBase(builder: flatbuffers.Builder): void;
      static addCmdId(builder: flatbuffers.Builder, cmdId: number): void;
      static addSync(builder: flatbuffers.Builder, sync: boolean): void;
      static addErrorKind(builder: flatbuffers.Builder, errorKind: ErrorKind): void;
      static addError(builder: flatbuffers.Builder, errorOffset: flatbuffers.Offset): void;
      static addInnerType(builder: flatbuffers.Builder, innerType: Any): void;
      static addInner(builder: flatbuffers.Builder, innerOffset: flatbuffers.Offset): void;
      static endBase(builder: flatbuffers.Builder): flatbuffers.Offset;
      static finishBaseBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
  }
  export class Start {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Start;
      static getRootAsStart(bb: flatbuffers.ByteBuffer, obj?: Start): Start;
      unused(): number;
      mutate_unused(value: number): boolean;
      static startStart(builder: flatbuffers.Builder): void;
      static addUnused(builder: flatbuffers.Builder, unused: number): void;
      static endStart(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class StartRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): StartRes;
      static getRootAsStartRes(bb: flatbuffers.ByteBuffer, obj?: StartRes): StartRes;
      cwd(): string | null;
      cwd(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      argv(index: number): string;
      argv(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;
      argvLength(): number;
      debugFlag(): boolean;
      mutate_debug_flag(value: boolean): boolean;
      depsFlag(): boolean;
      mutate_deps_flag(value: boolean): boolean;
      recompileFlag(): boolean;
      mutate_recompile_flag(value: boolean): boolean;
      typesFlag(): boolean;
      mutate_types_flag(value: boolean): boolean;
      versionFlag(): boolean;
      mutate_version_flag(value: boolean): boolean;
      configFile(): string | null;
      configFile(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      denoVersion(): string | null;
      denoVersion(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      v8Version(): string | null;
      v8Version(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startStartRes(builder: flatbuffers.Builder): void;
      static addCwd(builder: flatbuffers.Builder, cwdOffset: flatbuffers.Offset): void;
      static addArgv(builder: flatbuffers.Builder, argvOffset: flatbuffers.Offset): void;
      static createArgvVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
      static startArgvVector(builder: flatbuffers.Builder, numElems: number): void;
      static addDebugFlag(builder: flatbuffers.Builder, debugFlag: boolean): void;
      static addDepsFlag(builder: flatbuffers.Builder, depsFlag: boolean): void;
      static addRecompileFlag(builder: flatbuffers.Builder, recompileFlag: boolean): void;
      static addTypesFlag(builder: flatbuffers.Builder, typesFlag: boolean): void;
      static addVersionFlag(builder: flatbuffers.Builder, versionFlag: boolean): void;
      static addConfigFile(builder: flatbuffers.Builder, configFileOffset: flatbuffers.Offset): void;
      static addDenoVersion(builder: flatbuffers.Builder, denoVersionOffset: flatbuffers.Offset): void;
      static addV8Version(builder: flatbuffers.Builder, v8VersionOffset: flatbuffers.Offset): void;
      static endStartRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class CodeFetch {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): CodeFetch;
      static getRootAsCodeFetch(bb: flatbuffers.ByteBuffer, obj?: CodeFetch): CodeFetch;
      moduleSpecifier(): string | null;
      moduleSpecifier(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      containingFile(): string | null;
      containingFile(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startCodeFetch(builder: flatbuffers.Builder): void;
      static addModuleSpecifier(builder: flatbuffers.Builder, moduleSpecifierOffset: flatbuffers.Offset): void;
      static addContainingFile(builder: flatbuffers.Builder, containingFileOffset: flatbuffers.Offset): void;
      static endCodeFetch(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class CodeFetchRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): CodeFetchRes;
      static getRootAsCodeFetchRes(bb: flatbuffers.ByteBuffer, obj?: CodeFetchRes): CodeFetchRes;
      moduleName(): string | null;
      moduleName(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      filename(): string | null;
      filename(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      mediaType(): MediaType;
      mutate_media_type(value: MediaType): boolean;
      sourceCode(): string | null;
      sourceCode(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      outputCode(): string | null;
      outputCode(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      sourceMap(): string | null;
      sourceMap(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startCodeFetchRes(builder: flatbuffers.Builder): void;
      static addModuleName(builder: flatbuffers.Builder, moduleNameOffset: flatbuffers.Offset): void;
      static addFilename(builder: flatbuffers.Builder, filenameOffset: flatbuffers.Offset): void;
      static addMediaType(builder: flatbuffers.Builder, mediaType: MediaType): void;
      static addSourceCode(builder: flatbuffers.Builder, sourceCodeOffset: flatbuffers.Offset): void;
      static addOutputCode(builder: flatbuffers.Builder, outputCodeOffset: flatbuffers.Offset): void;
      static addSourceMap(builder: flatbuffers.Builder, sourceMapOffset: flatbuffers.Offset): void;
      static endCodeFetchRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class CodeCache {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): CodeCache;
      static getRootAsCodeCache(bb: flatbuffers.ByteBuffer, obj?: CodeCache): CodeCache;
      filename(): string | null;
      filename(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      sourceCode(): string | null;
      sourceCode(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      outputCode(): string | null;
      outputCode(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      sourceMap(): string | null;
      sourceMap(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startCodeCache(builder: flatbuffers.Builder): void;
      static addFilename(builder: flatbuffers.Builder, filenameOffset: flatbuffers.Offset): void;
      static addSourceCode(builder: flatbuffers.Builder, sourceCodeOffset: flatbuffers.Offset): void;
      static addOutputCode(builder: flatbuffers.Builder, outputCodeOffset: flatbuffers.Offset): void;
      static addSourceMap(builder: flatbuffers.Builder, sourceMapOffset: flatbuffers.Offset): void;
      static endCodeCache(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Chdir {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Chdir;
      static getRootAsChdir(bb: flatbuffers.ByteBuffer, obj?: Chdir): Chdir;
      directory(): string | null;
      directory(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startChdir(builder: flatbuffers.Builder): void;
      static addDirectory(builder: flatbuffers.Builder, directoryOffset: flatbuffers.Offset): void;
      static endChdir(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class SetTimeout {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): SetTimeout;
      static getRootAsSetTimeout(bb: flatbuffers.ByteBuffer, obj?: SetTimeout): SetTimeout;
      timeout(): number;
      mutate_timeout(value: number): boolean;
      static startSetTimeout(builder: flatbuffers.Builder): void;
      static addTimeout(builder: flatbuffers.Builder, timeout: number): void;
      static endSetTimeout(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Exit {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Exit;
      static getRootAsExit(bb: flatbuffers.ByteBuffer, obj?: Exit): Exit;
      code(): number;
      mutate_code(value: number): boolean;
      static startExit(builder: flatbuffers.Builder): void;
      static addCode(builder: flatbuffers.Builder, code: number): void;
      static endExit(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Environ {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Environ;
      static getRootAsEnviron(bb: flatbuffers.ByteBuffer, obj?: Environ): Environ;
      static startEnviron(builder: flatbuffers.Builder): void;
      static endEnviron(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class SetEnv {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): SetEnv;
      static getRootAsSetEnv(bb: flatbuffers.ByteBuffer, obj?: SetEnv): SetEnv;
      key(): string | null;
      key(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      value(): string | null;
      value(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startSetEnv(builder: flatbuffers.Builder): void;
      static addKey(builder: flatbuffers.Builder, keyOffset: flatbuffers.Offset): void;
      static addValue(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset): void;
      static endSetEnv(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class EnvironRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): EnvironRes;
      static getRootAsEnvironRes(bb: flatbuffers.ByteBuffer, obj?: EnvironRes): EnvironRes;
      map(index: number, obj?: KeyValue): KeyValue | null;
      mapLength(): number;
      static startEnvironRes(builder: flatbuffers.Builder): void;
      static addMap(builder: flatbuffers.Builder, mapOffset: flatbuffers.Offset): void;
      static createMapVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
      static startMapVector(builder: flatbuffers.Builder, numElems: number): void;
      static endEnvironRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class KeyValue {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): KeyValue;
      static getRootAsKeyValue(bb: flatbuffers.ByteBuffer, obj?: KeyValue): KeyValue;
      key(): string | null;
      key(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      value(): string | null;
      value(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startKeyValue(builder: flatbuffers.Builder): void;
      static addKey(builder: flatbuffers.Builder, keyOffset: flatbuffers.Offset): void;
      static addValue(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset): void;
      static endKeyValue(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Fetch {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Fetch;
      static getRootAsFetch(bb: flatbuffers.ByteBuffer, obj?: Fetch): Fetch;
      id(): number;
      mutate_id(value: number): boolean;
      url(): string | null;
      url(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startFetch(builder: flatbuffers.Builder): void;
      static addId(builder: flatbuffers.Builder, id: number): void;
      static addUrl(builder: flatbuffers.Builder, urlOffset: flatbuffers.Offset): void;
      static endFetch(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class FetchRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): FetchRes;
      static getRootAsFetchRes(bb: flatbuffers.ByteBuffer, obj?: FetchRes): FetchRes;
      id(): number;
      mutate_id(value: number): boolean;
      status(): number;
      mutate_status(value: number): boolean;
      headerKey(index: number): string;
      headerKey(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;
      headerKeyLength(): number;
      headerValue(index: number): string;
      headerValue(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;
      headerValueLength(): number;
      body(index: number): number | null;
      bodyLength(): number;
      bodyArray(): Uint8Array | null;
      static startFetchRes(builder: flatbuffers.Builder): void;
      static addId(builder: flatbuffers.Builder, id: number): void;
      static addStatus(builder: flatbuffers.Builder, status: number): void;
      static addHeaderKey(builder: flatbuffers.Builder, headerKeyOffset: flatbuffers.Offset): void;
      static createHeaderKeyVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
      static startHeaderKeyVector(builder: flatbuffers.Builder, numElems: number): void;
      static addHeaderValue(builder: flatbuffers.Builder, headerValueOffset: flatbuffers.Offset): void;
      static createHeaderValueVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
      static startHeaderValueVector(builder: flatbuffers.Builder, numElems: number): void;
      static addBody(builder: flatbuffers.Builder, bodyOffset: flatbuffers.Offset): void;
      static createBodyVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
      static startBodyVector(builder: flatbuffers.Builder, numElems: number): void;
      static endFetchRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class MakeTempDir {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): MakeTempDir;
      static getRootAsMakeTempDir(bb: flatbuffers.ByteBuffer, obj?: MakeTempDir): MakeTempDir;
      dir(): string | null;
      dir(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      prefix(): string | null;
      prefix(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      suffix(): string | null;
      suffix(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startMakeTempDir(builder: flatbuffers.Builder): void;
      static addDir(builder: flatbuffers.Builder, dirOffset: flatbuffers.Offset): void;
      static addPrefix(builder: flatbuffers.Builder, prefixOffset: flatbuffers.Offset): void;
      static addSuffix(builder: flatbuffers.Builder, suffixOffset: flatbuffers.Offset): void;
      static endMakeTempDir(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class MakeTempDirRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): MakeTempDirRes;
      static getRootAsMakeTempDirRes(bb: flatbuffers.ByteBuffer, obj?: MakeTempDirRes): MakeTempDirRes;
      path(): string | null;
      path(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startMakeTempDirRes(builder: flatbuffers.Builder): void;
      static addPath(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset): void;
      static endMakeTempDirRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Mkdir {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Mkdir;
      static getRootAsMkdir(bb: flatbuffers.ByteBuffer, obj?: Mkdir): Mkdir;
      path(): string | null;
      path(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      mode(): number;
      mutate_mode(value: number): boolean;
      static startMkdir(builder: flatbuffers.Builder): void;
      static addPath(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset): void;
      static addMode(builder: flatbuffers.Builder, mode: number): void;
      static endMkdir(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Chmod {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Chmod;
      static getRootAsChmod(bb: flatbuffers.ByteBuffer, obj?: Chmod): Chmod;
      path(): string | null;
      path(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      mode(): number;
      mutate_mode(value: number): boolean;
      static startChmod(builder: flatbuffers.Builder): void;
      static addPath(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset): void;
      static addMode(builder: flatbuffers.Builder, mode: number): void;
      static endChmod(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Remove {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Remove;
      static getRootAsRemove(bb: flatbuffers.ByteBuffer, obj?: Remove): Remove;
      path(): string | null;
      path(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      recursive(): boolean;
      mutate_recursive(value: boolean): boolean;
      static startRemove(builder: flatbuffers.Builder): void;
      static addPath(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset): void;
      static addRecursive(builder: flatbuffers.Builder, recursive: boolean): void;
      static endRemove(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class ReadFile {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): ReadFile;
      static getRootAsReadFile(bb: flatbuffers.ByteBuffer, obj?: ReadFile): ReadFile;
      filename(): string | null;
      filename(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startReadFile(builder: flatbuffers.Builder): void;
      static addFilename(builder: flatbuffers.Builder, filenameOffset: flatbuffers.Offset): void;
      static endReadFile(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class ReadFileRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): ReadFileRes;
      static getRootAsReadFileRes(bb: flatbuffers.ByteBuffer, obj?: ReadFileRes): ReadFileRes;
      data(index: number): number | null;
      dataLength(): number;
      dataArray(): Uint8Array | null;
      static startReadFileRes(builder: flatbuffers.Builder): void;
      static addData(builder: flatbuffers.Builder, dataOffset: flatbuffers.Offset): void;
      static createDataVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
      static startDataVector(builder: flatbuffers.Builder, numElems: number): void;
      static endReadFileRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class ReadDir {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): ReadDir;
      static getRootAsReadDir(bb: flatbuffers.ByteBuffer, obj?: ReadDir): ReadDir;
      path(): string | null;
      path(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startReadDir(builder: flatbuffers.Builder): void;
      static addPath(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset): void;
      static endReadDir(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class ReadDirRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): ReadDirRes;
      static getRootAsReadDirRes(bb: flatbuffers.ByteBuffer, obj?: ReadDirRes): ReadDirRes;
      entries(index: number, obj?: StatRes): StatRes | null;
      entriesLength(): number;
      static startReadDirRes(builder: flatbuffers.Builder): void;
      static addEntries(builder: flatbuffers.Builder, entriesOffset: flatbuffers.Offset): void;
      static createEntriesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
      static startEntriesVector(builder: flatbuffers.Builder, numElems: number): void;
      static endReadDirRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class WriteFile {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): WriteFile;
      static getRootAsWriteFile(bb: flatbuffers.ByteBuffer, obj?: WriteFile): WriteFile;
      filename(): string | null;
      filename(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      data(index: number): number | null;
      dataLength(): number;
      dataArray(): Uint8Array | null;
      perm(): number;
      mutate_perm(value: number): boolean;
      static startWriteFile(builder: flatbuffers.Builder): void;
      static addFilename(builder: flatbuffers.Builder, filenameOffset: flatbuffers.Offset): void;
      static addData(builder: flatbuffers.Builder, dataOffset: flatbuffers.Offset): void;
      static createDataVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
      static startDataVector(builder: flatbuffers.Builder, numElems: number): void;
      static addPerm(builder: flatbuffers.Builder, perm: number): void;
      static endWriteFile(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class CopyFile {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): CopyFile;
      static getRootAsCopyFile(bb: flatbuffers.ByteBuffer, obj?: CopyFile): CopyFile;
      from(): string | null;
      from(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      to(): string | null;
      to(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startCopyFile(builder: flatbuffers.Builder): void;
      static addFrom(builder: flatbuffers.Builder, fromOffset: flatbuffers.Offset): void;
      static addTo(builder: flatbuffers.Builder, toOffset: flatbuffers.Offset): void;
      static endCopyFile(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Rename {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Rename;
      static getRootAsRename(bb: flatbuffers.ByteBuffer, obj?: Rename): Rename;
      oldpath(): string | null;
      oldpath(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      newpath(): string | null;
      newpath(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startRename(builder: flatbuffers.Builder): void;
      static addOldpath(builder: flatbuffers.Builder, oldpathOffset: flatbuffers.Offset): void;
      static addNewpath(builder: flatbuffers.Builder, newpathOffset: flatbuffers.Offset): void;
      static endRename(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Readlink {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Readlink;
      static getRootAsReadlink(bb: flatbuffers.ByteBuffer, obj?: Readlink): Readlink;
      name(): string | null;
      name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startReadlink(builder: flatbuffers.Builder): void;
      static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset): void;
      static endReadlink(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class ReadlinkRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): ReadlinkRes;
      static getRootAsReadlinkRes(bb: flatbuffers.ByteBuffer, obj?: ReadlinkRes): ReadlinkRes;
      path(): string | null;
      path(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startReadlinkRes(builder: flatbuffers.Builder): void;
      static addPath(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset): void;
      static endReadlinkRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Resources {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Resources;
      static getRootAsResources(bb: flatbuffers.ByteBuffer, obj?: Resources): Resources;
      static startResources(builder: flatbuffers.Builder): void;
      static endResources(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Resource {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Resource;
      static getRootAsResource(bb: flatbuffers.ByteBuffer, obj?: Resource): Resource;
      rid(): number;
      mutate_rid(value: number): boolean;
      repr(): string | null;
      repr(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startResource(builder: flatbuffers.Builder): void;
      static addRid(builder: flatbuffers.Builder, rid: number): void;
      static addRepr(builder: flatbuffers.Builder, reprOffset: flatbuffers.Offset): void;
      static endResource(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class ResourcesRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): ResourcesRes;
      static getRootAsResourcesRes(bb: flatbuffers.ByteBuffer, obj?: ResourcesRes): ResourcesRes;
      resources(index: number, obj?: Resource): Resource | null;
      resourcesLength(): number;
      static startResourcesRes(builder: flatbuffers.Builder): void;
      static addResources(builder: flatbuffers.Builder, resourcesOffset: flatbuffers.Offset): void;
      static createResourcesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
      static startResourcesVector(builder: flatbuffers.Builder, numElems: number): void;
      static endResourcesRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Symlink {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Symlink;
      static getRootAsSymlink(bb: flatbuffers.ByteBuffer, obj?: Symlink): Symlink;
      oldname(): string | null;
      oldname(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      newname(): string | null;
      newname(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startSymlink(builder: flatbuffers.Builder): void;
      static addOldname(builder: flatbuffers.Builder, oldnameOffset: flatbuffers.Offset): void;
      static addNewname(builder: flatbuffers.Builder, newnameOffset: flatbuffers.Offset): void;
      static endSymlink(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Stat {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Stat;
      static getRootAsStat(bb: flatbuffers.ByteBuffer, obj?: Stat): Stat;
      filename(): string | null;
      filename(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      lstat(): boolean;
      mutate_lstat(value: boolean): boolean;
      static startStat(builder: flatbuffers.Builder): void;
      static addFilename(builder: flatbuffers.Builder, filenameOffset: flatbuffers.Offset): void;
      static addLstat(builder: flatbuffers.Builder, lstat: boolean): void;
      static endStat(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class StatRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): StatRes;
      static getRootAsStatRes(bb: flatbuffers.ByteBuffer, obj?: StatRes): StatRes;
      isFile(): boolean;
      mutate_is_file(value: boolean): boolean;
      isSymlink(): boolean;
      mutate_is_symlink(value: boolean): boolean;
      len(): flatbuffers.Long;
      mutate_len(value: flatbuffers.Long): boolean;
      modified(): flatbuffers.Long;
      mutate_modified(value: flatbuffers.Long): boolean;
      accessed(): flatbuffers.Long;
      mutate_accessed(value: flatbuffers.Long): boolean;
      created(): flatbuffers.Long;
      mutate_created(value: flatbuffers.Long): boolean;
      mode(): number;
      mutate_mode(value: number): boolean;
      hasMode(): boolean;
      mutate_has_mode(value: boolean): boolean;
      name(): string | null;
      name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      path(): string | null;
      path(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startStatRes(builder: flatbuffers.Builder): void;
      static addIsFile(builder: flatbuffers.Builder, isFile: boolean): void;
      static addIsSymlink(builder: flatbuffers.Builder, isSymlink: boolean): void;
      static addLen(builder: flatbuffers.Builder, len: flatbuffers.Long): void;
      static addModified(builder: flatbuffers.Builder, modified: flatbuffers.Long): void;
      static addAccessed(builder: flatbuffers.Builder, accessed: flatbuffers.Long): void;
      static addCreated(builder: flatbuffers.Builder, created: flatbuffers.Long): void;
      static addMode(builder: flatbuffers.Builder, mode: number): void;
      static addHasMode(builder: flatbuffers.Builder, hasMode: boolean): void;
      static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset): void;
      static addPath(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset): void;
      static endStatRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Truncate {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Truncate;
      static getRootAsTruncate(bb: flatbuffers.ByteBuffer, obj?: Truncate): Truncate;
      name(): string | null;
      name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      len(): number;
      mutate_len(value: number): boolean;
      static startTruncate(builder: flatbuffers.Builder): void;
      static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset): void;
      static addLen(builder: flatbuffers.Builder, len: number): void;
      static endTruncate(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Open {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Open;
      static getRootAsOpen(bb: flatbuffers.ByteBuffer, obj?: Open): Open;
      filename(): string | null;
      filename(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      perm(): number;
      mutate_perm(value: number): boolean;
      static startOpen(builder: flatbuffers.Builder): void;
      static addFilename(builder: flatbuffers.Builder, filenameOffset: flatbuffers.Offset): void;
      static addPerm(builder: flatbuffers.Builder, perm: number): void;
      static endOpen(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class OpenRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): OpenRes;
      static getRootAsOpenRes(bb: flatbuffers.ByteBuffer, obj?: OpenRes): OpenRes;
      rid(): number;
      mutate_rid(value: number): boolean;
      static startOpenRes(builder: flatbuffers.Builder): void;
      static addRid(builder: flatbuffers.Builder, rid: number): void;
      static endOpenRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Read {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Read;
      static getRootAsRead(bb: flatbuffers.ByteBuffer, obj?: Read): Read;
      rid(): number;
      mutate_rid(value: number): boolean;
      static startRead(builder: flatbuffers.Builder): void;
      static addRid(builder: flatbuffers.Builder, rid: number): void;
      static endRead(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class ReadRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): ReadRes;
      static getRootAsReadRes(bb: flatbuffers.ByteBuffer, obj?: ReadRes): ReadRes;
      nread(): number;
      mutate_nread(value: number): boolean;
      eof(): boolean;
      mutate_eof(value: boolean): boolean;
      static startReadRes(builder: flatbuffers.Builder): void;
      static addNread(builder: flatbuffers.Builder, nread: number): void;
      static addEof(builder: flatbuffers.Builder, eof: boolean): void;
      static endReadRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Write {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Write;
      static getRootAsWrite(bb: flatbuffers.ByteBuffer, obj?: Write): Write;
      rid(): number;
      mutate_rid(value: number): boolean;
      static startWrite(builder: flatbuffers.Builder): void;
      static addRid(builder: flatbuffers.Builder, rid: number): void;
      static endWrite(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class WriteRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): WriteRes;
      static getRootAsWriteRes(bb: flatbuffers.ByteBuffer, obj?: WriteRes): WriteRes;
      nbyte(): number;
      mutate_nbyte(value: number): boolean;
      static startWriteRes(builder: flatbuffers.Builder): void;
      static addNbyte(builder: flatbuffers.Builder, nbyte: number): void;
      static endWriteRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Close {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Close;
      static getRootAsClose(bb: flatbuffers.ByteBuffer, obj?: Close): Close;
      rid(): number;
      mutate_rid(value: number): boolean;
      static startClose(builder: flatbuffers.Builder): void;
      static addRid(builder: flatbuffers.Builder, rid: number): void;
      static endClose(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Shutdown {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Shutdown;
      static getRootAsShutdown(bb: flatbuffers.ByteBuffer, obj?: Shutdown): Shutdown;
      rid(): number;
      mutate_rid(value: number): boolean;
      how(): number;
      mutate_how(value: number): boolean;
      static startShutdown(builder: flatbuffers.Builder): void;
      static addRid(builder: flatbuffers.Builder, rid: number): void;
      static addHow(builder: flatbuffers.Builder, how: number): void;
      static endShutdown(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Listen {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Listen;
      static getRootAsListen(bb: flatbuffers.ByteBuffer, obj?: Listen): Listen;
      network(): string | null;
      network(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      address(): string | null;
      address(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startListen(builder: flatbuffers.Builder): void;
      static addNetwork(builder: flatbuffers.Builder, networkOffset: flatbuffers.Offset): void;
      static addAddress(builder: flatbuffers.Builder, addressOffset: flatbuffers.Offset): void;
      static endListen(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class ListenRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): ListenRes;
      static getRootAsListenRes(bb: flatbuffers.ByteBuffer, obj?: ListenRes): ListenRes;
      rid(): number;
      mutate_rid(value: number): boolean;
      static startListenRes(builder: flatbuffers.Builder): void;
      static addRid(builder: flatbuffers.Builder, rid: number): void;
      static endListenRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Accept {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Accept;
      static getRootAsAccept(bb: flatbuffers.ByteBuffer, obj?: Accept): Accept;
      rid(): number;
      mutate_rid(value: number): boolean;
      static startAccept(builder: flatbuffers.Builder): void;
      static addRid(builder: flatbuffers.Builder, rid: number): void;
      static endAccept(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Dial {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Dial;
      static getRootAsDial(bb: flatbuffers.ByteBuffer, obj?: Dial): Dial;
      network(): string | null;
      network(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      address(): string | null;
      address(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startDial(builder: flatbuffers.Builder): void;
      static addNetwork(builder: flatbuffers.Builder, networkOffset: flatbuffers.Offset): void;
      static addAddress(builder: flatbuffers.Builder, addressOffset: flatbuffers.Offset): void;
      static endDial(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class NewConn {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): NewConn;
      static getRootAsNewConn(bb: flatbuffers.ByteBuffer, obj?: NewConn): NewConn;
      rid(): number;
      mutate_rid(value: number): boolean;
      remoteAddr(): string | null;
      remoteAddr(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      localAddr(): string | null;
      localAddr(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
      static startNewConn(builder: flatbuffers.Builder): void;
      static addRid(builder: flatbuffers.Builder, rid: number): void;
      static addRemoteAddr(builder: flatbuffers.Builder, remoteAddrOffset: flatbuffers.Offset): void;
      static addLocalAddr(builder: flatbuffers.Builder, localAddrOffset: flatbuffers.Offset): void;
      static endNewConn(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class Metrics {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): Metrics;
      static getRootAsMetrics(bb: flatbuffers.ByteBuffer, obj?: Metrics): Metrics;
      static startMetrics(builder: flatbuffers.Builder): void;
      static endMetrics(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  export class MetricsRes {
      bb: flatbuffers.ByteBuffer | null;
      bb_pos: number;
      __init(i: number, bb: flatbuffers.ByteBuffer): MetricsRes;
      static getRootAsMetricsRes(bb: flatbuffers.ByteBuffer, obj?: MetricsRes): MetricsRes;
      opsDispatched(): flatbuffers.Long;
      mutate_ops_dispatched(value: flatbuffers.Long): boolean;
      opsCompleted(): flatbuffers.Long;
      mutate_ops_completed(value: flatbuffers.Long): boolean;
      bytesSentControl(): flatbuffers.Long;
      mutate_bytes_sent_control(value: flatbuffers.Long): boolean;
      bytesSentData(): flatbuffers.Long;
      mutate_bytes_sent_data(value: flatbuffers.Long): boolean;
      bytesReceived(): flatbuffers.Long;
      mutate_bytes_received(value: flatbuffers.Long): boolean;
      static startMetricsRes(builder: flatbuffers.Builder): void;
      static addOpsDispatched(builder: flatbuffers.Builder, opsDispatched: flatbuffers.Long): void;
      static addOpsCompleted(builder: flatbuffers.Builder, opsCompleted: flatbuffers.Long): void;
      static addBytesSentControl(builder: flatbuffers.Builder, bytesSentControl: flatbuffers.Long): void;
      static addBytesSentData(builder: flatbuffers.Builder, bytesSentData: flatbuffers.Long): void;
      static addBytesReceived(builder: flatbuffers.Builder, bytesReceived: flatbuffers.Long): void;
      static endMetricsRes(builder: flatbuffers.Builder): flatbuffers.Offset;
  }
  
}