Skip to content

Instantly share code, notes, and snippets.

@kitsonk

kitsonk/deno.d.ts

Created November 5, 2018 04:04
Show Gist options
  • Save kitsonk/995804846dd509bdf02d70a627d428bd to your computer and use it in GitHub Desktop.
Save kitsonk/995804846dd509bdf02d70a627d428bd to your computer and use it in GitHub Desktop.
Download ZIP
Raw
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;
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment