SYMBOL INDEX (1209 symbols across 127 files)

FILE: bin/genieacs-cwmp.ts
  constant SERVICE_ADDRESS (line 12) | const SERVICE_ADDRESS = config.get("CWMP_INTERFACE") as string;
  constant SERVICE_PORT (line 13) | const SERVICE_PORT = config.get("CWMP_PORT") as number;
  function exitWorkerGracefully (line 15) | function exitWorkerGracefully(): void {
  function exitWorkerUngracefully (line 26) | function exitWorkerUngracefully(): void {

FILE: bin/genieacs-ext.ts
  function errorToFault (line 7) | function errorToFault(err: Error): Fault {

FILE: bin/genieacs-fs.ts
  constant SERVICE_ADDRESS (line 11) | const SERVICE_ADDRESS = config.get("FS_INTERFACE") as string;
  constant SERVICE_PORT (line 12) | const SERVICE_PORT = config.get("FS_PORT") as number;
  function exitWorkerGracefully (line 14) | function exitWorkerGracefully(): void {
  function exitWorkerUngracefully (line 21) | function exitWorkerUngracefully(): void {

FILE: bin/genieacs-nbi.ts
  constant SERVICE_ADDRESS (line 12) | const SERVICE_ADDRESS = config.get("NBI_INTERFACE") as string;
  constant SERVICE_PORT (line 13) | const SERVICE_PORT = config.get("NBI_PORT") as number;
  function exitWorkerGracefully (line 15) | function exitWorkerGracefully(): void {
  function exitWorkerUngracefully (line 26) | function exitWorkerUngracefully(): void {

FILE: bin/genieacs-ui.ts
  constant SERVICE_ADDRESS (line 12) | const SERVICE_ADDRESS = config.get("UI_INTERFACE") as string;
  constant SERVICE_PORT (line 13) | const SERVICE_PORT = config.get("UI_PORT") as number;
  function exitWorkerGracefully (line 15) | function exitWorkerGracefully(): void {
  function exitWorkerUngracefully (line 26) | function exitWorkerUngracefully(): void {

FILE: build/assets.ts
  constant APP_JS (line 1) | const APP_JS = "app.js";
  constant APP_CSS (line 2) | const APP_CSS = "app.css";
  constant ICONS_SVG (line 3) | const ICONS_SVG = "icons.svg";
  constant LOGO_SVG (line 4) | const LOGO_SVG = "logo.svg";
  constant FAVICON_PNG (line 5) | const FAVICON_PNG = "favicon.png";

FILE: build/build.ts
  constant MODE (line 26) | const MODE = process.env["NODE_ENV"] || "production";
  constant INPUT_DIR (line 28) | const INPUT_DIR = process.cwd();
  constant OUTPUT_DIR (line 29) | const OUTPUT_DIR = path.join(INPUT_DIR, "dist");
  function rmDir (line 31) | async function rmDir(dirPath: string): Promise<void> {
  function stripDevDeps (line 44) | function stripDevDeps(deps): void {
  function stripDevDeps2 (line 54) | function stripDevDeps2(deps): void {
  function xmlTostring (line 62) | function xmlTostring(xml): string {
  function assetHash (line 71) | function assetHash(buffer: Buffer | string): string {
  constant ASSETS (line 75) | const ASSETS = {} as {
  method setup (line 85) | setup(build) {
  method setup (line 97) | setup(build) {
  method setup (line 110) | setup(build) {
  method setup (line 122) | setup(build) {
  function generateSymbol (line 147) | function generateSymbol(id: string, svgStr: string): string {
  function getBuildMetadata (line 164) | async function getBuildMetadata(): Promise<string> {
  function init (line 182) | async function init(): Promise<void> {
  function copyStatic (line 220) | async function copyStatic(): Promise<void> {
  function generateCss (line 251) | async function generateCss(): Promise<void> {
  function generateBackendJs (line 290) | async function generateBackendJs(): Promise<void> {
  function generateFrontendJs (line 326) | async function generateFrontendJs(): Promise<void> {
  function generateIconsSprite (line 358) | async function generateIconsSprite(): Promise<void> {

FILE: build/lint.ts
  function runEslint (line 6) | async function runEslint(): Promise<string> {
  function runTsc (line 23) | async function runTsc(): Promise<string> {
  function runPrettier (line 34) | async function runPrettier(): Promise<string> {
  function runAll (line 45) | async function runAll(): Promise<void> {

FILE: build/test.ts
  constant INPUT_DIR (line 6) | const INPUT_DIR = process.cwd();
  method setup (line 11) | setup(build) {
  method setup (line 28) | setup(build) {
  function buildTests (line 52) | async function buildTests(): Promise<void> {

FILE: docs/ext-sample.js
  function latlong (line 12) | function latlong(args, callback) {

FILE: lib/api-functions.ts
  constant XMPP_CONFIGURED (line 43) | const XMPP_CONFIGURED = !!config.get("XMPP_JID");
  function connectionRequest (line 45) | async function connectionRequest(
  function awaitSessionStart (line 212) | async function awaitSessionStart(
  function awaitSessionEnd (line 232) | async function awaitSessionEnd(
  function sanitizeTask (line 245) | function sanitizeTask(task): void {
  function insertTasks (line 349) | async function insertTasks(tasks: any[]): Promise<Task[]> {
  function deleteDevice (line 367) | async function deleteDevice(deviceId: string): Promise<void> {
  function deleteFault (line 390) | async function deleteFault(id: string): Promise<void> {
  function deleteResource (line 405) | async function deleteResource(
  function putResource (line 446) | async function putResource(
  function authLocal (line 482) | function authLocal(

FILE: lib/auth.ts
  function parseHeaderFeilds (line 3) | function parseHeaderFeilds(str: string): Record<string, string> {
  function parseAuthorizationHeader (line 36) | function parseAuthorizationHeader(authHeader: string): {
  function parseWwwAuthenticateHeader (line 60) | function parseWwwAuthenticateHeader(
  function basic (line 70) | function basic(username: string, password: string): string {
  function digest (line 74) | function digest(
  function solveDigest (line 119) | function solveDigest(
  function generateSalt (line 162) | function generateSalt(length: number): Promise<string> {
  function hashPassword (line 171) | function hashPassword(pass: string, salt: string): Promise<string> {

FILE: lib/bundle-views.ts
  function validateViewScript (line 6) | async function validateViewScript(
  function buildInput (line 26) | function buildInput(views: Views): string {
  function bundleViews (line 49) | async function bundleViews(views: Views): Promise<string> {
  function runBuild (line 53) | async function runBuild(input: string): Promise<string> {

FILE: lib/cache.ts
  constant CLOCK_SKEW_TOLERANCE (line 4) | const CLOCK_SKEW_TOLERANCE = 30000;
  constant MAX_CACHE_TTL (line 5) | const MAX_CACHE_TTL = +config.get("MAX_CACHE_TTL");
  function get (line 7) | async function get(key: string): Promise<string> {
  function del (line 12) | async function del(key: string): Promise<void> {
  function set (line 16) | async function set(
  function pop (line 32) | async function pop(key: string): Promise<string> {

FILE: lib/cluster.ts
  function fork (line 8) | function fork(): Worker {
  function restartWorker (line 20) | function restartWorker(worker, code, signal): void {
  function start (line 73) | function start(
  function stop (line 100) | function stop(): void {

FILE: lib/common/authorizer.ts
  class Authorizer (line 4) | class Authorizer {
    method constructor (line 13) | public constructor(permissionSets: PermissionSet[]) {
    method hasAccess (line 20) | public hasAccess(resourceType: string, access: number): boolean {
    method getFilter (line 41) | public getFilter(resourceType: string, access: number): Expression {
    method getValidator (line 60) | public getValidator(
    method getPermissionSets (line 126) | public getPermissionSets(): PermissionSet[] {

FILE: lib/common/debounce.ts
  function debounce (line 1) | function debounce<T>(

FILE: lib/common/errors.ts
  class ResourceLockedError (line 1) | class ResourceLockedError extends Error {
    method constructor (line 2) | constructor(message: string) {

FILE: lib/common/expression.ts
  type Value (line 9) | type Value = string | number | boolean | null;
  method toString (line 19) | toString(): string {
  method evaluate (line 24) | evaluate<T extends Expression>(fn: (e: Expression) => T = (e) => e as T)...
  method evaluateAsync (line 28) | async evaluateAsync<T extends Expression>(
  method parse (line 36) | static parse(input: string): Expression {
  method and (line 43) | static and(left: Expression, right: Expression): Expression {
  method or (line 81) | static or(left: Expression, right: Expression): Expression {
  class Literal (line 122) | class Literal extends Expression {
    method constructor (line 123) | constructor(public readonly value: Value) {
    method map (line 127) | map(): Literal {
    method mapAsync (line 131) | async mapAsync(): Promise<Literal> {
  class Parameter (line 136) | class Parameter extends Expression {
    method constructor (line 137) | constructor(public readonly path: Path) {
    method map (line 141) | map(): Parameter {
    method mapAsync (line 145) | async mapAsync(): Promise<Parameter> {
    method toString (line 149) | toString(): string {
  class Unary (line 154) | class Unary extends Expression {
    method constructor (line 155) | constructor(
    method map (line 162) | map(fn: (e: Expression, i: number) => Expression): Unary {
    method mapAsync (line 168) | async mapAsync(
  class Binary (line 177) | class Binary extends Expression {
    method constructor (line 178) | constructor(
    method map (line 186) | map(fn: (e: Expression, i: number) => Expression): Binary {
    method mapAsync (line 193) | async mapAsync(
  class FunctionCall (line 203) | class FunctionCall extends Expression {
    method constructor (line 204) | constructor(
    method map (line 211) | map(fn: (e: Expression, i: number) => Expression): FunctionCall {
    method mapAsync (line 217) | async mapAsync(
  class Conditional (line 226) | class Conditional extends Expression {
    method constructor (line 227) | constructor(
    method map (line 235) | map(fn: (e: Expression, i: number) => Expression): Conditional {
    method mapAsync (line 248) | async mapAsync(
  function extractPaths (line 265) | function extractPaths(exp: Expression): Path[] {
  function parseList (line 276) | function parseList(input: string): Expression[] {

FILE: lib/common/expression/evaluate.ts
  function compare (line 4) | function compare(
  function toNumber (line 14) | function toNumber(a: boolean | number | string): number {
  function toString (line 25) | function toString(a: boolean | number | string): string {
  function reduce (line 38) | function reduce(exp: Expression): Expression {

FILE: lib/common/expression/normalize.ts
  class Indeterminates (line 4) | class Indeterminates {
    method constructor (line 8) | public constructor(exp?: Expression) {
    method reciprocal (line 18) | public reciprocal(): Indeterminates {
    method multiply (line 26) | public static multiply(
    method compare (line 64) | public static compare(a: Indeterminates, b: Indeterminates): number {
  type Term (line 82) | interface Term {
  function findGcd (line 88) | function findGcd(a: bigint, b: bigint): bigint {
  class Polynomial (line 97) | class Polynomial extends Expression {
    method constructor (line 100) | public constructor(terms: Term[]) {
    method map (line 105) | map(): Polynomial {
    method mapAsync (line 109) | async mapAsync(): Promise<Polynomial> {
    method simplifyTerms (line 113) | public static simplifyTerms(terms: Term[]): Term[] {
    method fromIndeterminate (line 148) | public static fromIndeterminate(indeterminate: Expression): Polynomial {
    method fromConstant (line 160) | public static fromConstant(constant: number): Polynomial {
    method negation (line 181) | public negation(): Polynomial {
    method reciprocal (line 191) | public reciprocal(): Polynomial {
    method constant (line 200) | public constant(): Polynomial {
    method add (line 205) | public add(rhs: Polynomial): Polynomial {
    method subtract (line 211) | public subtract(rhs: Polynomial): Polynomial {
    method multiply (line 215) | public multiply(rhs: Polynomial): Polynomial {
    method divide (line 239) | public divide(rhs: Polynomial): Polynomial {
    method toExpression (line 243) | public toExpression(): Expression {
  constant SWAPPED_OPS (line 286) | const SWAPPED_OPS = {
  function cartesianProduct (line 295) | function cartesianProduct<T>(arrays: T[][]): T[][] {
  function toPolynomial (line 302) | function toPolynomial(e: Expression): Polynomial {
  function fromPolynomial (line 314) | function fromPolynomial(e: Expression): Expression {
  function normalizeCallback (line 320) | function normalizeCallback(exp: Expression): Expression {
  function normalize (line 488) | function normalize(exp: Expression): Expression {

FILE: lib/common/expression/pagination.ts
  type Bookmark (line 7) | type Bookmark = Record<string, null | boolean | number | string>;
  type Minterm (line 9) | type Minterm = number[];
  function toBookmark (line 11) | function toBookmark(
  function bookmarkToExpression (line 24) | function bookmarkToExpression(
  function getCover (line 61) | function getCover(
  function paginate (line 124) | function paginate(

FILE: lib/common/expression/parser.ts
  class Cursor (line 4) | class Cursor {
    method constructor (line 11) | constructor(input: string) {
    method fork (line 19) | fork(): Cursor {
    method sync (line 28) | sync(cursor: Cursor): void {
    method read (line 35) | read(cur: Cursor): string {
    method step (line 39) | step(): Cursor {
    method walk (line 47) | walk(callback: (charCode: number) => boolean): Cursor {
    method descend (line 52) | descend(chars: number[], override = true): void {
    method ascend (line 60) | ascend(): void {
    method skipwhitespace (line 66) | skipwhitespace(): Cursor {
  constant CHAR_SINGLE_QUOTE (line 71) | const CHAR_SINGLE_QUOTE = 39;
  constant CHAR_DOUBLE_QUOTE (line 72) | const CHAR_DOUBLE_QUOTE = 34;
  constant CHAR_OPEN_PAREN (line 73) | const CHAR_OPEN_PAREN = 40;
  constant CHAR_CLOSE_PAREN (line 74) | const CHAR_CLOSE_PAREN = 41;
  constant CHAR_COMMA (line 75) | const CHAR_COMMA = 44;
  constant CHAR_PERIOD (line 76) | const CHAR_PERIOD = 46;
  constant CHAR_COLON (line 77) | const CHAR_COLON = 58;
  constant CHAR_OPEN_BRACKET (line 78) | const CHAR_OPEN_BRACKET = 91;
  constant CHAR_BACKSLASH (line 79) | const CHAR_BACKSLASH = 92;
  constant CHAR_CLOSE_BRACKET (line 80) | const CHAR_CLOSE_BRACKET = 93;
  constant BINARY_OPERATORS (line 82) | const BINARY_OPERATORS = [
  constant PRECEDENCE (line 101) | const PRECEDENCE = {
  constant PATH_CHARS (line 127) | const PATH_CHARS = new Set<number>([
  function findOperator (line 138) | function findOperator(cursor: Cursor): string {
  function interpretEscapes (line 166) | function interpretEscapes(str): string {
  function parseExpression (line 185) | function parseExpression(cursor: Cursor, presedence = 0): Expression {
  function parseOldAliasValue (line 317) | function parseOldAliasValue(cursor: Cursor): string {
  function parseOldAlias (line 364) | function parseOldAlias(cursor: Cursor): Expression {
  function parsePath (line 402) | function parsePath(cur: Cursor): Path {
  function stringifyExpression (line 461) | function stringifyExpression(exp: Expression, level = 0): string {
  function parseLikePattern (line 511) | function parseLikePattern(pat: string, esc: string): string[] {
  function likePatternToRegExp (line 529) | function likePatternToRegExp(pat: string, esc = "", flags = ""): RegExp {

FILE: lib/common/expression/synth.ts
  type Minterm (line 6) | type Minterm = number[];
  method getVar (line 15) | public getVar(c: U): number {
  method getClause (line 26) | public getClause(v: number): U {
  method canRaise (line 33) | canRaise(idx: number, set: Set<number>): boolean {
  method canLower (line 38) | canLower(idx: number, set: Set<number>): boolean {
  method bias (line 42) | bias(a: number, b: number): number {
  method sanitizeMinterms (line 47) | sanitizeMinterms(minterms: Minterm[]): Minterm[] {
  method minimize (line 51) | minimize(minterms: Minterm[], dcSet: Minterm[] = []): Minterm[] {
  method expression (line 94) | expression(): Expression {
  method isBoolean (line 102) | isBoolean(): boolean {
  method isNullable (line 105) | isNullable(c: Clause.IsNull): boolean {
  method getNullables (line 113) | *getNullables(): IterableIterator<Clause.IsNull> {
  method toString (line 120) | toString(): string {
  class Not (line 127) | class Not extends Clause {
    method constructor (line 128) | constructor(public operand: Clause) {
    method getMinterms (line 131) | getMinterms(context: SynthContextBase<Clause>, res: number): Minterm[] {
  class And (line 139) | class And extends Clause {
    method constructor (line 140) | constructor(public operands: Clause[]) {
    method getMinterms (line 143) | getMinterms(context: SynthContextBase<Clause>, res: number): Minterm[] {
  class IsNull (line 167) | class IsNull extends Clause {
    method constructor (line 168) | constructor(public operand: Clause) {
    method getMinterms (line 171) | getMinterms(context: SynthContextBase<Clause>, res: number): Minterm[] {
    method isBoolean (line 181) | isBoolean(): boolean {
    method getNullables (line 184) | *getNullables(): IterableIterator<IsNull> {
    method expression (line 187) | expression(): Expression {
  class Exp (line 195) | class Exp extends Clause {
    method constructor (line 196) | constructor(public exp: Expression) {
    method getMinterms (line 199) | getMinterms(context: SynthContextBase<Clause>, res: number): Minterm[] {
    method expression (line 207) | expression(): Expression {
    method isBoolean (line 210) | isBoolean(): boolean {
  class Compare (line 222) | class Compare extends Clause {
    method constructor (line 223) | constructor(
    method getMinterms (line 230) | getMinterms(context: SynthContextBase<Clause>, res: number): Minterm[] {
    method getNullables (line 238) | *getNullables(): IterableIterator<IsNull> {
    method isBoolean (line 241) | isBoolean(): boolean {
    method expression (line 244) | expression(): Expression {
  class Like (line 253) | class Like extends Clause {
    method constructor (line 259) | constructor(
    method getMinterms (line 282) | getMinterms(context: SynthContextBase<Clause>, res: number): Minterm[] {
    method isBoolean (line 290) | isBoolean(): boolean {
    method isNullable (line 293) | isNullable(c: IsNull): boolean {
    method getNullables (line 296) | getNullables(): IterableIterator<IsNull> {
    method expression (line 299) | expression(): Expression {
  class Conditional (line 318) | class Conditional extends Clause {
    method constructor (line 319) | constructor(
    method getMinterms (line 326) | getMinterms(context: SynthContextBase<Clause>, res: number): Minterm[] {
    method expression (line 337) | expression(): Expression {
    method isBoolean (line 393) | isBoolean(): boolean {
  function fromExpression (line 398) | function fromExpression(exp: Expression): Clause {
  function groupBy (line 458) | function groupBy<T, K>(
  class SynthContext (line 473) | class SynthContext extends SynthContextBase<Clause, Clause> {
    method constructor (line 474) | constructor() {
    method getMinterms (line 478) | getMinterms(clause: Clause, res: number): number[][] {
    method getDcSet (line 498) | getDcSet(minterms: Minterm[]): number[][] {
    method canRaise (line 721) | canRaise(idx: number, set: Set<number>): boolean {
    method canLower (line 734) | canLower(idx: number, set: Set<number>): boolean {
    method bias (line 741) | bias(a: number, b: number): number {
    method sanitizeMinterms (line 746) | sanitizeMinterms(minterms: Minterm[]): Minterm[] {
    method toExpression (line 796) | toExpression(sop: number[][]): Expression {
  function createSynthContext (line 857) | function createSynthContext(): SynthContext {
  function likeMatches (line 861) | function likeMatches(
  function getLikePrefixUpperBound (line 903) | function getLikePrefixUpperBound(prefix: string): string | null {
  function getPureLikePrefix (line 916) | function getPureLikePrefix(pattern: string[]): string | null {
  function likeImplies (line 943) | function likeImplies(pat1: string[], pat2: string[]): boolean {
  function likeDisjoint (line 961) | function likeDisjoint(pat1: string[], pat2: string[]): boolean {
  function minimize (line 990) | function minimize(expr: Expression, boolean = false): Expression {
  function unionDiff (line 996) | function unionDiff(
  function covers (line 1029) | function covers(expr1: Expression, expr2: Expression): boolean {
  function areEquivalent (line 1049) | function areEquivalent(expr1: Expression, expr2: Expression): boolean {
  function subtract (line 1088) | function subtract(expr1: Expression, expr2: Expression): Expression {

FILE: lib/common/memoize.ts
  function getKey (line 5) | function getKey(obj): string {
  function memoize (line 23) | function memoize<T extends (...args: any[]) => any>(func: T): T {

FILE: lib/common/path-set.ts
  class PathSet (line 3) | class PathSet {
    method constructor (line 8) | public constructor() {}
    method add (line 10) | public add(pathStr: string): Path {
    method get (line 43) | public get(path: string): Path {
    method findCompat (line 47) | public findCompat(
    method find (line 64) | public find(path: Path, paramMask: number, attrMask: number): Path[] {

FILE: lib/common/path.ts
  type Segments (line 4) | type Segments = (string | Expression)[];
  class Path (line 9) | class Path {
    method constructor (line 17) | constructor(segments: Segments, colon: number) {
    method parse (line 49) | public static parse(input: string): Path {
    method length (line 64) | public get length(): number {
    method paramLength (line 68) | public get paramLength(): number {
    method attrLength (line 72) | public get attrLength(): number {
    method toString (line 76) | public toString(): string {
    method slice (line 80) | public slice(start = 0, end: number = this.segments.length): Path {
    method concat (line 112) | public concat(path2: Path): Path {
    method stripAlias (line 145) | public stripAlias(): Path {

FILE: lib/common/yaml.ts
  constant LINE_WIDTH (line 1) | const LINE_WIDTH = 80;
  constant INDENTATION (line 2) | const INDENTATION = "  ";
  constant STRING_RESERVED (line 4) | const STRING_RESERVED = new Set([
  function isPrintable (line 16) | function isPrintable(str: string): boolean {
  function stringifyKey (line 22) | function stringifyKey(str: string): string {
  function foldString (line 29) | function foldString(str: string): string[] {
  function stringifyString (line 66) | function stringifyString(str: string, res: string[], prefix1, prefix2): ...
  function stringifyAny (line 128) | function stringifyAny(
  function stringify (line 213) | function stringify(obj: unknown): string {

FILE: lib/config.ts
  constant ROOT_DIR (line 5) | let ROOT_DIR = resolve(__dirname, "..");
  function setConfig (line 92) | function setConfig(name, value, commandLineArgument = false): boolean {
  function get (line 240) | function get(
  function getDefault (line 271) | function getDefault(optionName: string): string | number | boolean {

FILE: lib/connection-request.ts
  function extractAuth (line 13) | async function extractAuth(
  function httpGet (line 50) | function httpGet(
  function httpConnectionRequest (line 78) | async function httpConnectionRequest(
  function udpConnectionRequest (line 175) | async function udpConnectionRequest(
  constant XMPP_JID (line 228) | const XMPP_JID = config.get("XMPP_JID") as string;
  constant XMPP_PASSWORD (line 229) | const XMPP_PASSWORD = config.get("XMPP_PASSWORD") as string;
  constant XMPP_RESOURCE (line 230) | const XMPP_RESOURCE = crypto.randomBytes(8).toString("hex");
  function xmppClientOnError (line 234) | function xmppClientOnError(err: Error): void {
  function xmppClientOnClose (line 243) | function xmppClientOnClose(): void {
  function xmppConnectionRequest (line 247) | async function xmppConnectionRequest(

FILE: lib/cwmp.ts
  constant REALM (line 52) | const REALM = "GenieACS";
  constant MAX_CYCLES (line 53) | const MAX_CYCLES = 4;
  constant MAX_CONCURRENT_REQUESTS (line 54) | const MAX_CONCURRENT_REQUESTS = +config.get("MAX_CONCURRENT_REQUESTS");
  constant MAX_SESSION_DURATION (line 56) | const MAX_SESSION_DURATION = 300000;
  constant LOCK_REFRESH_INTERVAL (line 57) | const LOCK_REFRESH_INTERVAL = 10000;
  constant REQUEST_TIMEOUT (line 58) | const REQUEST_TIMEOUT = 10000;
  function authenticate (line 70) | async function authenticate(
  function writeResponse (line 168) | async function writeResponse(
  function recordFault (line 237) | function recordFault(
  function inform (line 304) | async function inform(
  function transferComplete (line 336) | async function transferComplete(sessionContext, rpc): Promise<void> {
  function appendProvisions (line 370) | function appendProvisions(original, toAppend): boolean {
  function applyPresets (line 401) | async function applyPresets(sessionContext: SessionContext): Promise<voi...
  function nextRpc (line 615) | async function nextRpc(sessionContext: SessionContext): Promise<void> {
  function endSession (line 756) | async function endSession(sessionContext: SessionContext): Promise<void> {
  function sendAcsRequest (line 827) | async function sendAcsRequest(
  function onConnection (line 874) | async function onConnection(socket: Socket): Promise<void> {
  function onClientError (line 928) | async function onClientError(err: Error, socket: Socket): Promise<void> {
  function reportBadState (line 966) | async function reportBadState(sessionContext: SessionContext): Promise<v...
  function responseUnauthorized (line 981) | async function responseUnauthorized(
  function processRequest (line 1018) | async function processRequest(
  function listener (line 1258) | async function listener(
  function clientError (line 1273) | async function clientError(
  function decodeString (line 1318) | function decodeString(buffer: Buffer, charset: string): string {
  function listenerAsync (line 1327) | async function listenerAsync(

FILE: lib/cwmp/db.ts
  constant INVALID_PATH_SUFFIX (line 14) | const INVALID_PATH_SUFFIX = "__invalid";
  function compareAccessLists (line 16) | function compareAccessLists(list1: string[], list2: string[]): boolean {
  function fetchDevice (line 22) | async function fetchDevice(
  function saveDevice (line 237) | async function saveDevice(
  function getFaults (line 546) | async function getFaults(
  function saveFault (line 571) | async function saveFault(
  function deleteFault (line 592) | async function deleteFault(
  function getDueTasks (line 599) | async function getDueTasks(
  function clearTasks (line 663) | async function clearTasks(
  function getOperations (line 672) | async function getOperations(
  function saveOperation (line 702) | async function saveOperation(
  function deleteOperation (line 722) | async function deleteOperation(

FILE: lib/cwmp/local-cache.ts
  type Snapshot (line 17) | interface Snapshot {
  function flattenObject (line 25) | function flattenObject<T extends Record<keyof T, unknown>>(
  function fetchPresets (line 39) | async function fetchPresets(): Promise<[string, Preset[]]> {
  function fetchProvisions (line 216) | async function fetchProvisions(): Promise<[string, Provisions]> {
  function fetchVirtualParameters (line 237) | async function fetchVirtualParameters(): Promise<[string, VirtualParamet...
  function fetchFiles (line 258) | async function fetchFiles(): Promise<[string, Files]> {
  function fetchConfig (line 273) | async function fetchConfig(): Promise<[string, Config]> {
  function refresh (line 290) | async function refresh(): Promise<[string, Snapshot]> {
  function getRevision (line 313) | async function getRevision(): Promise<string> {
  function getPresets (line 317) | function getPresets(revision: string): Preset[] {
  function getProvisions (line 321) | function getProvisions(revision: string): Provisions {
  function getVirtualParameters (line 325) | function getVirtualParameters(revision: string): VirtualParameters {
  function getFiles (line 329) | function getFiles(revision: string): Files {
  function getConfig (line 351) | function getConfig(
  function getConfigExpression (line 367) | function getConfigExpression(

FILE: lib/db/db.ts
  function connect (line 27) | async function connect(): Promise<void> {
  function disconnect (line 57) | async function disconnect(): Promise<void> {

FILE: lib/db/synth.ts
  type Minterm (line 15) | type Minterm = number[];
  function getParam (line 17) | function getParam(exp: Expression, collection: string): string {
  function getTypes (line 37) | function getTypes(parameter: string, collection: string): string[] {
  function roundOid (line 112) | function roundOid(oid: string, roundUp: boolean): string {
  function groupBy (line 126) | function groupBy<T, K>(
  method toString (line 144) | toString(): string {
  class MongoClauseArray (line 149) | class MongoClauseArray extends MongoClause {
    method constructor (line 150) | constructor(
    method toQuery (line 157) | toQuery(truthy: boolean): Filter<unknown> {
  class MongoClauseCompare (line 163) | class MongoClauseCompare<T> extends MongoClause {
    method constructor (line 164) | constructor(
    method toQuery (line 173) | toQuery(truthy: boolean): Filter<unknown> {
  class MongoClauseType (line 185) | class MongoClauseType extends MongoClause {
    method constructor (line 186) | constructor(
    method toQuery (line 193) | toQuery(truthy: boolean): Filter<unknown> {
  class MongoClauseLike (line 199) | class MongoClauseLike extends MongoClause {
    method constructor (line 201) | constructor(
    method toQuery (line 211) | toQuery(truthy: boolean): Filter<unknown> {
  class MongoSynthContext (line 251) | class MongoSynthContext extends SynthContextBase<Clause, MongoClause> {
    method constructor (line 252) | constructor(private readonly collection: string) {
    method getMinterms (line 256) | getMinterms(clause: Clause, res: number): number[][] {
    method getDcSet (line 421) | getDcSet(minterms: Minterm[]): number[][] {
    method canRaise (line 569) | canRaise(i: number, s: Set<number>): boolean {
    method toQuery (line 584) | toQuery(minterms: Minterm[]): Filter<unknown> {
  function toMongoQuery (line 643) | function toMongoQuery(
  function validQuery (line 656) | function validQuery(exp: Expression, resource: string): void {

FILE: lib/db/types.ts
  type Fault (line 5) | interface Fault {
  type TaskBase (line 24) | interface TaskBase {
  type View (line 32) | interface View {
  type TaskGetParameterValues (line 37) | interface TaskGetParameterValues extends TaskBase {
  type TaskSetParameterValues (line 42) | interface TaskSetParameterValues extends TaskBase {
  type TaskRefreshObject (line 47) | interface TaskRefreshObject extends TaskBase {
  type TaskReboot (line 52) | interface TaskReboot extends TaskBase {
  type TaskFactoryReset (line 56) | interface TaskFactoryReset extends TaskBase {
  type TaskDownload (line 60) | interface TaskDownload extends TaskBase {
  type TaskAddObject (line 67) | interface TaskAddObject extends TaskBase {
  type TaskDeleteObject (line 73) | interface TaskDeleteObject extends TaskBase {
  type TaskProvisions (line 78) | interface TaskProvisions extends TaskBase {
  type Task (line 83) | type Task =
  type Operation (line 94) | interface Operation {
  type Config (line 104) | interface Config {
  type Cache (line 109) | interface Cache {
  type Device (line 116) | interface Device {
  type Configuration (line 124) | type Configuration =
  type Preset (line 133) | interface Preset {
  type Object (line 141) | interface Object {
  type Provision (line 145) | interface Provision {
  type VirtualParameter (line 150) | interface VirtualParameter {
  type File (line 155) | interface File {
  type Permission (line 168) | interface Permission {
  type User (line 177) | interface User {
  type Lock (line 184) | interface Lock {

FILE: lib/db/util.ts
  function optimizeProjection (line 7) | function optimizeProjection(obj: { [path: string]: 1 }): {
  function convertOldPrecondition (line 28) | function convertOldPrecondition(q: Record<string, unknown>): Expression {

FILE: lib/debug.ts
  constant DEBUG_FILE (line 8) | const DEBUG_FILE = "" + config.get("DEBUG_FILE");
  constant DEBUG_FORMAT (line 9) | const DEBUG_FORMAT = "" + config.get("DEBUG_FORMAT");
  function getConnectionTimestamp (line 13) | function getConnectionTimestamp(connection: Socket): Date {
  function incomingHttpRequest (line 22) | function incomingHttpRequest(
  function outgoingHttpResponse (line 51) | function outgoingHttpResponse(
  function outgoingHttpRequest (line 78) | function outgoingHttpRequest(
  function outgoingHttpRequestError (line 108) | function outgoingHttpRequestError(
  function incomingHttpResponse (line 137) | function incomingHttpResponse(
  function outgoingUdpMessage (line 163) | function outgoingUdpMessage(
  function clientError (line 187) | function clientError(remoteAddress: string, err: Error): void {
  function outgoingXmppStanza (line 204) | function outgoingXmppStanza(deviceId: string, body: string): void {
  function incomingXmppStanza (line 221) | function incomingXmppStanza(deviceId: string, body: string): void {

FILE: lib/default-provisions.ts
  constant MAX_DEPTH (line 7) | const MAX_DEPTH = +config.get("MAX_DEPTH");
  function refresh (line 9) | function refresh(
  function value (line 65) | function value(
  function tag (line 108) | function tag(
  function reboot (line 132) | function reboot(
  function reset (line 151) | function reset(
  function download (line 170) | function download(
  function instances (line 213) | function instances(

FILE: lib/device.ts
  constant CHANGE_FLAGS (line 11) | const CHANGE_FLAGS = {
  function parseBool (line 19) | function parseBool(v): boolean {
  function sanitizeParameterValue (line 27) | function sanitizeParameterValue(
  function getAliasDeclarations (line 69) | function getAliasDeclarations(
  function expressionToAlias (line 104) | function expressionToAlias(exp: Expression): [Path, Value][] {
  function unpack (line 120) | function unpack(
  function clear (line 192) | function clear(
  function compareEquality (line 257) | function compareEquality(a, b): boolean {
  function set (line 272) | function set(
  function track (line 386) | function track(
  function clearTrackers (line 407) | function clearTrackers(

FILE: lib/extensions.ts
  constant TIMEOUT (line 9) | const TIMEOUT = +config.get("EXT_TIMEOUT");
  function run (line 14) | function run(args: string[]): Promise<{ fault: Fault; value: any }> {
  function kill (line 83) | function kill(process: ChildProcess): Promise<void> {
  function killAll (line 102) | async function killAll(): Promise<void> {

FILE: lib/forwarded.ts
  type RequestOrigin (line 7) | interface RequestOrigin {
  constant FORWARDED_HEADER (line 16) | const FORWARDED_HEADER = "" + config.get("FORWARDED_HEADER");
  function parseForwardedHeader (line 34) | function parseForwardedHeader(str: string): { [name: string]: string } {
  function getRequestOrigin (line 79) | function getRequestOrigin(request: IncomingMessage): RequestOrigin {

FILE: lib/fs.ts
  function generateETag (line 57) | function generateETag(file: {
  function matchEtag (line 67) | function matchEtag(etag: string, header: string): boolean {
  function listener (line 82) | async function listener(

FILE: lib/gpn-heuristic.ts
  constant WILDCARD_MULTIPLIER (line 3) | const WILDCARD_MULTIPLIER = 2;
  constant UNDISCOVERED_DEPTH (line 4) | const UNDISCOVERED_DEPTH = 7;
  function estimateGpnCount (line 13) | function estimateGpnCount(

FILE: lib/init.ts
  type Status (line 28) | interface Status {
  function getStatus (line 37) | async function getStatus(): Promise<Status> {
  function seed (line 64) | async function seed(options: Record<string, boolean>): Promise<void> {

FILE: lib/instance-set.ts
  type Instance (line 1) | interface Instance {
  class InstanceSet (line 5) | class InstanceSet {
    method constructor (line 8) | public constructor() {
    method add (line 12) | public add(instance: Instance): void {
    method delete (line 16) | public delete(instance: Instance): void {
    method superset (line 20) | public superset(instance: Instance): Instance[] {
    method subset (line 56) | public subset(instance: Instance): Instance[] {
    method forEach (line 97) | public forEach(callback: (instance: Instance) => void): void {
    method values (line 101) | public values(): IterableIterator<Instance> {
    method clear (line 105) | public clear(): void {
    method size (line 109) | public get size(): number {
  method [Symbol.iterator] (line 93) | public [Symbol.iterator](): IterableIterator<Instance> {

FILE: lib/local-cache.ts
  constant REFRESH (line 5) | const REFRESH = 5000;
  constant EVICT_TIMEOUT (line 6) | const EVICT_TIMEOUT = 120000;
  class LocalCache (line 8) | class LocalCache<T> {
    method constructor (line 13) | constructor(
    method getRevision (line 18) | async getRevision(): Promise<string> {
    method hasRevision (line 23) | hasRevision(revision: string): boolean {
    method get (line 27) | get(revision: string): T {
    method refresh (line 33) | async refresh(): Promise<void> {

FILE: lib/lock.ts
  constant CLOCK_SKEW_TOLERANCE (line 3) | const CLOCK_SKEW_TOLERANCE = 30000;
  function acquireLock (line 5) | async function acquireLock(
  function releaseLock (line 36) | async function releaseLock(
  function getToken (line 47) | async function getToken(lockName: string): Promise<string> {

FILE: lib/logger.ts
  constant REOPEN_EVERY (line 14) | const REOPEN_EVERY = 60000;
  constant LOG_FORMAT (line 16) | const LOG_FORMAT = config.get("LOG_FORMAT");
  constant ACCESS_LOG_FORMAT (line 17) | const ACCESS_LOG_FORMAT = config.get("ACCESS_LOG_FORMAT") || LOG_FORMAT;
  constant LOG_SYSTEMD (line 21) | let LOG_SYSTEMD = false;
  constant ACCESS_LOG_SYSTEMD (line 22) | let ACCESS_LOG_SYSTEMD = false;
  constant LOG_FILE (line 24) | let LOG_FILE, ACCESS_LOG_FILE;
  constant ACCESS_LOG_FILE (line 24) | let LOG_FILE, ACCESS_LOG_FILE;
  type WritableStream (line 29) | interface WritableStream {
  type WriteStream (line 36) | interface WriteStream {
  function reopen (line 47) | function reopen(): void {
  function init (line 96) | function init(service: string, version: string): void {
  function close (line 133) | function close(): void {
  function flatten (line 138) | function flatten(
  function formatJson (line 216) | function formatJson(
  function formatSimple (line 232) | function formatSimple(
  function log (line 280) | function log(details: Record<string, unknown>): void {
  function info (line 290) | function info(details: Record<string, unknown>): void {
  function warn (line 295) | function warn(details: Record<string, unknown>): void {
  function error (line 300) | function error(details: Record<string, unknown>): void {
  function accessLog (line 305) | function accessLog(details: Record<string, unknown>): void {
  function accessInfo (line 315) | function accessInfo(details: Record<string, unknown>): void {
  function accessWarn (line 320) | function accessWarn(details: Record<string, unknown>): void {
  function accessError (line 325) | function accessError(details: Record<string, unknown>): void {

FILE: lib/nbi.ts
  constant DEVICE_TASKS_REGEX (line 19) | const DEVICE_TASKS_REGEX = /^\/devices\/([a-zA-Z0-9\-_%]+)\/tasks\/?$/;
  constant TASKS_REGEX (line 20) | const TASKS_REGEX = /^\/tasks\/([a-zA-Z0-9\-_%]+)(\/[a-zA-Z_]*)?$/;
  constant TAGS_REGEX (line 21) | const TAGS_REGEX =
  constant PRESETS_REGEX (line 23) | const PRESETS_REGEX = /^\/presets\/([a-zA-Z0-9\-_%]+)\/?$/;
  constant OBJECTS_REGEX (line 24) | const OBJECTS_REGEX = /^\/objects\/([a-zA-Z0-9\-_%]+)\/?$/;
  constant FILES_REGEX (line 25) | const FILES_REGEX = /^\/files\/([a-zA-Z0-9%!*'();:@&=+$,?#[\]\-_.~]+)\/?$/;
  constant PING_REGEX (line 26) | const PING_REGEX = /^\/ping\/([a-zA-Z0-9\-_.:]+)\/?$/;
  constant QUERY_REGEX (line 27) | const QUERY_REGEX = /^\/([a-zA-Z0-9_]+)\/?$/;
  constant DELETE_DEVICE_REGEX (line 28) | const DELETE_DEVICE_REGEX = /^\/devices\/([a-zA-Z0-9\-_%]+)\/?$/;
  constant PROVISIONS_REGEX (line 29) | const PROVISIONS_REGEX = /^\/provisions\/([a-zA-Z0-9\-_%]+)\/?$/;
  constant VIRTUAL_PARAMETERS_REGEX (line 30) | const VIRTUAL_PARAMETERS_REGEX =
  constant FAULTS_REGEX (line 32) | const FAULTS_REGEX = /^\/faults\/([a-zA-Z0-9\-_%:]+)\/?$/;
  function getBody (line 34) | async function getBody(request: IncomingMessage): Promise<Buffer> {
  function listener (line 48) | async function listener(
  function handler (line 73) | async function handler(

FILE: lib/ping.ts
  type PingResult (line 5) | interface PingResult {
  function isValidHost (line 15) | function isValidHost(host: string): boolean {
  function parsePing (line 24) | function parsePing(osPlatform: string, stdout: string): PingResult {
  function ping (line 70) | function ping(

FILE: lib/query.ts
  function isObject (line 1) | function isObject(obj: any): boolean {
  function stringToRegexp (line 5) | function stringToRegexp(input, flags?): RegExp | false {
  function normalize (line 19) | function normalize(input): any {
  constant EXPAND_OPS (line 38) | const EXPAND_OPS = new Set([
  function expandValue (line 49) | function expandValue(value: unknown): unknown[] {
  function permute (line 86) | function permute(param, val): any[] {
  function expand (line 101) | function expand(
  function sanitizeQueryTypes (line 129) | function sanitizeQueryTypes(

FILE: lib/sandbox.ts
  constant COMMIT (line 11) | const COMMIT = Symbol();
  constant EXT (line 14) | const EXT = Symbol();
  constant UNDEFINED (line 16) | const UNDEFINED = undefined;
  function runExtension (line 26) | function runExtension(sessionContext, key, extCall): Promise<Fault> {
  class SandboxDate (line 53) | class SandboxDate {
    method constructor (line 54) | public constructor(
    method now (line 70) | public static now(intervalOrCron, variance): number {
    method parse (line 94) | public static parse(dateString: string): number {
    method UTC (line 98) | public static UTC(
  function random (line 105) | function random(): number {
  class ParameterWrapper (line 115) | class ParameterWrapper {
    method constructor (line 116) | public constructor(path: Path, attributes, unpacked?, unpackedRevision...
  function declare (line 201) | function declare(
  function clear (line 254) | function clear(path: string, timestamp: number, attributes?): void {
  function commit (line 261) | function commit(): void {
  function ext (line 275) | function ext(...args: unknown[]): any {
  function log (line 287) | function log(msg: string, meta: Record<string, unknown>): void {
  function errorToFault (line 317) | function errorToFault(err: Error): Fault {
  function run (line 348) | async function run(

FILE: lib/scheduling.ts
  function md532 (line 4) | function md532(str): number {
  function variance (line 14) | function variance(deviceId: string, vrnc: number): number {
  function interval (line 18) | function interval(
  function parseCron (line 26) | function parseCron(cronExp: string): any {
  function cron (line 33) | function cron(

FILE: lib/server.ts
  function closeServer (line 12) | function closeServer(timeout, callback): void {
  type ServerOptions (line 37) | interface ServerOptions {
  type SocketEndpoint (line 48) | interface SocketEndpoint {
  type Promisify (line 59) | type Promisify<T extends (...args: any) => any> = (
  function getValidPrivKeys (line 63) | function getValidPrivKeys(value: string): Buffer[] {
  function getValidCerts (line 73) | function getValidCerts(value: string): Buffer[] {
  function start (line 83) | function start(
  function stop (line 147) | function stop(terminateConnections = true): Promise<void> {
  function getSocketEndpoints (line 157) | function getSocketEndpoints(socket: Socket): SocketEndpoint {

FILE: lib/session.ts
  constant VALID_PARAM_TYPES (line 46) | const VALID_PARAM_TYPES = new Set([
  function initDeviceData (line 56) | function initDeviceData(): DeviceData {
  function init (line 66) | function init(
  function generateRpcId (line 94) | function generateRpcId(sessionContext: SessionContext): string {
  function configContextCallback (line 102) | function configContextCallback(
  function inform (line 126) | async function inform(
  function transferComplete (line 255) | async function transferComplete(
  function revertDownloadParameters (line 360) | function revertDownloadParameters(
  function timeoutOperations (line 388) | async function timeoutOperations(
  function addProvisions (line 460) | function addProvisions(
  function clearProvisions (line 518) | function clearProvisions(sessionContext: SessionContext): void {
  function runProvisions (line 551) | async function runProvisions(
  function runVirtualParameters (line 630) | async function runVirtualParameters(
  function runDeclarations (line 747) | function runDeclarations(
  function rpcRequest (line 977) | async function rpcRequest(
  function generateGetRpcRequest (line 1493) | function generateGetRpcRequest(
  function compareAccessLists (line 1716) | function compareAccessLists(list1: string[], list2: string[]): boolean {
  function generateSetRpcRequest (line 1722) | function generateSetRpcRequest(
  function generateGetVirtualParameterProvisions (line 1922) | function generateGetVirtualParameterProvisions(
  function generateSetVirtualParameterProvisions (line 1968) | function generateSetVirtualParameterProvisions(
  function processDeclarations (line 2023) | function processDeclarations(
  function processInstances (line 2330) | function processInstances(
  function rpcResponse (line 2391) | async function rpcResponse(
  function rpcFault (line 2870) | async function rpcFault(
  function deserialize (line 2933) | async function deserialize(
  function serialize (line 2960) | async function serialize(

FILE: lib/soap.ts
  constant SERVER_NAME (line 35) | const SERVER_NAME = `GenieACS/${VERSION}`;
  constant NAMESPACES (line 37) | const NAMESPACES = {
  function parseBool (line 79) | function parseBool(v: string): boolean {
  function event (line 85) | function event(xml: Element): string[] {
  function parameterInfoList (line 91) | function parameterInfoList(xml: Element): [Path, boolean, boolean][] {
  function parameterValueList (line 141) | function parameterValueList(
  function parameterAttributeList (line 216) | function parameterAttributeList(xml: Element): [Path, number, string[]][] {
  function GetParameterNames (line 265) | function GetParameterNames(methodRequest): string {
  function GetParameterNamesResponse (line 271) | function GetParameterNamesResponse(xml): GetParameterNamesResponse {
  function GetParameterValues (line 280) | function GetParameterValues(methodRequest): string {
  function GetParameterValuesResponse (line 288) | function GetParameterValuesResponse(xml: Element): GetParameterValuesRes...
  function GetParameterAttributes (line 297) | function GetParameterAttributes(methodRequest): string {
  function GetParameterAttributesResponse (line 305) | function GetParameterAttributesResponse(
  function SetParameterValues (line 316) | function SetParameterValues(methodRequest): string {
  function SetParameterValuesResponse (line 338) | function SetParameterValuesResponse(xml: Element): SetParameterValuesRes...
  function SetParameterAttributes (line 363) | function SetParameterAttributes(methodRequest): string {
  function SetParameterAttributesResponse (line 387) | function SetParameterAttributesResponse(): SetParameterAttributesResponse {
  function AddObject (line 393) | function AddObject(methodRequest): string {
  function AddObjectResponse (line 401) | function AddObjectResponse(xml: Element): AddObjectResponse {
  function DeleteObject (line 432) | function DeleteObject(methodRequest): string {
  function DeleteObjectResponse (line 440) | function DeleteObjectResponse(xml: Element): DeleteObjectResponse {
  function Reboot (line 465) | function Reboot(methodRequest): string {
  function RebootResponse (line 471) | function RebootResponse(): RebootResponse {
  function FactoryReset (line 477) | function FactoryReset(): string {
  function FactoryResetResponse (line 481) | function FactoryResetResponse(): FactoryResetResponse {
  function Download (line 487) | function Download(methodRequest): string {
  function DownloadResponse (line 509) | function DownloadResponse(xml: Element): DownloadResponse {
  function Inform (line 557) | function Inform(xml: Element): InformRequest {
  function InformResponse (line 620) | function InformResponse(): string {
  function GetRPCMethods (line 624) | function GetRPCMethods(): GetRPCMethodsRequest {
  function GetRPCMethodsResponse (line 628) | function GetRPCMethodsResponse(methodResponse): string {
  function TransferComplete (line 636) | function TransferComplete(xml: Element): TransferCompleteRequest {
  function TransferCompleteResponse (line 699) | function TransferCompleteResponse(): string {
  function RequestDownload (line 703) | function RequestDownload(xml: Element): RequestDownloadRequest {
  function RequestDownloadResponse (line 710) | function RequestDownloadResponse(): string {
  function AcsFault (line 714) | function AcsFault(f: CpeFault): string {
  function faultStruct (line 726) | function faultStruct(xml: Element): FaultStruct {
  function fault (line 784) | function fault(xml: Element): CpeFault {
  function request (line 821) | function request(
  function response (line 981) | function response(rpc: {

FILE: lib/types.ts
  type Fault (line 9) | interface Fault {
  type SessionFault (line 22) | interface SessionFault extends Fault {
  type Attributes (line 31) | interface Attributes {
  type AttributeTimestamps (line 39) | interface AttributeTimestamps {
  type AttributeValues (line 47) | interface AttributeValues {
  type DeviceData (line 55) | interface DeviceData {
  type VirtualParameterDeclaration (line 63) | type VirtualParameterDeclaration = [
  type SyncState (line 83) | interface SyncState {
  type SessionContext (line 108) | interface SessionContext {
  type Task (line 152) | interface Task {
  type Operation (line 165) | interface Operation {
  type AcsRequest (line 179) | type AcsRequest =
  type GetParameterNames (line 191) | interface GetParameterNames {
  type GetParameterValues (line 197) | interface GetParameterValues {
  type GetParameterAttributes (line 202) | interface GetParameterAttributes {
  type SetParameterValues (line 207) | interface SetParameterValues {
  type SetParameterAttributes (line 215) | interface SetParameterAttributes {
  type AddObject (line 220) | interface AddObject {
  type DeleteObject (line 227) | interface DeleteObject {
  type FactoryReset (line 233) | interface FactoryReset {
  type Reboot (line 238) | interface Reboot {
  type Download (line 243) | interface Download {
  type SpvFault (line 259) | interface SpvFault {
  type FaultStruct (line 265) | interface FaultStruct {
  type CpeFault (line 271) | interface CpeFault {
  type CpeResponse (line 277) | type CpeResponse =
  type GetParameterNamesResponse (line 289) | interface GetParameterNamesResponse {
  type GetParameterValuesResponse (line 294) | interface GetParameterValuesResponse {
  type GetParameterAttributesResponse (line 299) | interface GetParameterAttributesResponse {
  type SetParameterValuesResponse (line 304) | interface SetParameterValuesResponse {
  type SetParameterAttributesResponse (line 309) | interface SetParameterAttributesResponse {
  type AddObjectResponse (line 313) | interface AddObjectResponse {
  type DeleteObjectResponse (line 319) | interface DeleteObjectResponse {
  type RebootResponse (line 324) | interface RebootResponse {
  type FactoryResetResponse (line 328) | interface FactoryResetResponse {
  type DownloadResponse (line 332) | interface DownloadResponse {
  type CpeRequest (line 339) | type CpeRequest =
  type InformRequest (line 345) | interface InformRequest {
  type TransferCompleteRequest (line 358) | interface TransferCompleteRequest {
  type GetRPCMethodsRequest (line 366) | interface GetRPCMethodsRequest {
  type RequestDownloadRequest (line 370) | interface RequestDownloadRequest {
  type AcsResponse (line 375) | type AcsResponse =
  type InformResponse (line 381) | interface InformResponse {
  type GetRPCMethodsResponse (line 385) | interface GetRPCMethodsResponse {
  type TransferCompleteResponse (line 390) | interface TransferCompleteResponse {
  type RequestDownloadResponse (line 394) | interface RequestDownloadResponse {
  type QueryOptions (line 398) | interface QueryOptions {
  type Declaration (line 407) | interface Declaration {
  type Clear (line 428) | type Clear = [
  type Preset (line 441) | interface Preset {
  type Provisions (line 450) | interface Provisions {
  type VirtualParameters (line 454) | interface VirtualParameters {
  type Views (line 458) | interface Views {
  type Files (line 462) | interface Files {
  type Users (line 466) | interface Users {
  type Permissions (line 470) | interface Permissions {
  type PermissionSet (line 482) | type PermissionSet = {
  type Config (line 490) | interface Config {
  type UiConfig (line 494) | type UiConfig = Record<string, string>;
  type SoapMessage (line 496) | interface SoapMessage {
  type ScriptResult (line 506) | interface ScriptResult {

FILE: lib/ui.ts
  constant JWT_SECRET (line 24) | const JWT_SECRET = "" + config.get("UI_JWT_SECRET");
  constant JWT_COOKIE (line 25) | const JWT_COOKIE = "genieacs-ui-jwt";
  function success (line 119) | function success(authMethod): void {
  function failure (line 133) | function failure(): void {

FILE: lib/ui/api.ts
  function logUnauthorizedWarning (line 24) | function logUnauthorizedWarning(log): void {
  constant RESOURCE_DELETE (line 29) | const RESOURCE_DELETE = 1 << 0;
  constant RESOURCE_PUT (line 30) | const RESOURCE_PUT = 1 << 1;
  constant RESOURCE_IDS (line 32) | const RESOURCE_IDS = {
  function singleParam (line 60) | function singleParam(p: string | string[]): string {
  function flushRow (line 104) | function flushRow(): void {

FILE: lib/ui/db.ts
  function processDeviceProjection (line 13) | function processDeviceProjection(
  function processDeviceSort (line 41) | function processDeviceSort(
  function parseDate (line 59) | function parseDate(d: Date): number | string {
  type FlatDevice (line 64) | interface FlatDevice {
  function flattenDevice (line 68) | function flattenDevice(device: Record<string, unknown>): FlatDevice {
  function flattenFault (line 162) | function flattenFault(fault: unknown): Fault {
  function flattenTask (line 169) | function flattenTask(task: unknown): Task {
  function flattenPreset (line 177) | function flattenPreset(
  function flattenFile (line 216) | function flattenFile(file: Record<string, unknown>): Record<string, unkn...
  function preProcessPreset (line 228) | function preProcessPreset(data: Record<string, unknown>): MongoTypes.Pre...
  type QueryOptions (line 268) | interface QueryOptions {
  function count (line 334) | function count(resource: string, filter: Expression): Promise<number> {
  function updateDeviceTags (line 348) | async function updateDeviceTags(
  function putPreset (line 368) | async function putPreset(
  function deletePreset (line 376) | async function deletePreset(id: string): Promise<void> {
  function putProvision (line 380) | async function putProvision(
  function deleteProvision (line 403) | async function deleteProvision(id: string): Promise<void> {
  function putVirtualParameter (line 407) | async function putVirtualParameter(
  function deleteVirtualParameter (line 430) | async function deleteVirtualParameter(id: string): Promise<void> {
  function putConfig (line 434) | async function putConfig(
  function deleteConfig (line 441) | async function deleteConfig(id: string): Promise<void> {
  function putPermission (line 445) | async function putPermission(
  function deletePermission (line 454) | async function deletePermission(id: string): Promise<void> {
  function putUser (line 458) | async function putUser(
  function deleteUser (line 470) | async function deleteUser(id: string): Promise<void> {
  function downloadFile (line 474) | function downloadFile(filename: string): Readable {
  function putFile (line 478) | function putFile(
  function deleteFile (line 514) | async function deleteFile(filename: string): Promise<void> {
  function deleteFault (line 518) | async function deleteFault(id: string): Promise<void> {
  function deleteTask (line 522) | async function deleteTask(id: ObjectId): Promise<void> {
  function putView (line 526) | async function putView(
  function deleteView (line 538) | async function deleteView(id: string): Promise<void> {

FILE: lib/ui/local-cache.ts
  type Snapshot (line 8) | interface Snapshot {
  function fetchPermissions (line 16) | async function fetchPermissions(): Promise<[string, Permissions]> {
  function fetchUsers (line 42) | async function fetchUsers(): Promise<[string, Users]> {
  function fetchConfig (line 62) | async function fetchConfig(): Promise<[string, Config, UiConfig]> {
  function fetchViews (line 84) | async function fetchViews(): Promise<[string, Views]> {
  function refresh (line 99) | async function refresh(): Promise<[string, Snapshot]> {
  function getRevision (line 121) | async function getRevision(): Promise<string> {
  function getConfig (line 143) | function getConfig(
  function getConfigExpression (line 159) | function getConfigExpression(revision: string, key: string): Expression {
  function getUsers (line 164) | function getUsers(revision: string): Users {
  function getPermissions (line 169) | function getPermissions(revision: string): Permissions {
  function getUiConfig (line 174) | function getUiConfig(revision: string): UiConfig {
  function getViewsBundle (line 179) | function getViewsBundle(revision: string): string {

FILE: lib/util.ts
  function generateDeviceId (line 3) | function generateDeviceId(
  function escapeRegExp (line 30) | function escapeRegExp(str: string): string {
  function encodeTag (line 34) | function encodeTag(tag: string): string {
  function decodeTag (line 44) | function decodeTag(tag: string): string {
  function once (line 48) | function once(
  function setTimeoutPromise (line 65) | function setTimeoutPromise(delay: number, ref = true): Promise<void> {

FILE: lib/versioned-map.ts
  constant NONEXISTENT (line 1) | const NONEXISTENT = Symbol();
  constant UNDEFINED (line 2) | const UNDEFINED = undefined;
  type Revisions (line 4) | interface Revisions<V> {
  class VersionedMap (line 9) | class VersionedMap<K, V> {
    method constructor (line 15) | public constructor() {
    method size (line 22) | public get size(): number {
    method revision (line 26) | public get revision(): number {
    method revision (line 30) | public set revision(rev: number) {
    method get (line 37) | public get(key: K, rev = this._revision): V {
    method has (line 46) | public has(key: K, rev = this._revision): boolean {
    method set (line 55) | public set(key: K, value: V, rev = this._revision): this {
    method delete (line 82) | public delete(key: K, rev = this._revision): boolean {
    method getRevisions (line 101) | public getRevisions(key: K): Revisions<V> {
    method setRevisions (line 120) | public setRevisions(key: K, revisionsObj: Revisions<V>): void {
    method getDiff (line 144) | public getDiff(key: K): [V, V] {
    method diff (line 154) | public *diff(): IterableIterator<[K, V, V]> {
    method collapse (line 166) | public collapse(revision: number): void {
  method [Symbol.iterator] (line 187) | public *[Symbol.iterator](): IterableIterator<[K, V]> {

FILE: lib/xml-parser.ts
  constant CHAR_SINGLE_QUOTE (line 1) | const CHAR_SINGLE_QUOTE = 39;
  constant CHAR_DOUBLE_QUOTE (line 2) | const CHAR_DOUBLE_QUOTE = 34;
  constant CHAR_LESS_THAN (line 3) | const CHAR_LESS_THAN = 60;
  constant CHAR_GREATER_THAN (line 4) | const CHAR_GREATER_THAN = 62;
  constant CHAR_COLON (line 5) | const CHAR_COLON = 58;
  constant CHAR_SPACE (line 6) | const CHAR_SPACE = 32;
  constant CHAR_TAB (line 7) | const CHAR_TAB = 9;
  constant CHAR_CR (line 8) | const CHAR_CR = 13;
  constant CHAR_LF (line 9) | const CHAR_LF = 10;
  constant CHAR_SLASH (line 10) | const CHAR_SLASH = 47;
  constant CHAR_EXMARK (line 11) | const CHAR_EXMARK = 33;
  constant CHAR_QMARK (line 12) | const CHAR_QMARK = 63;
  constant CHAR_EQUAL (line 13) | const CHAR_EQUAL = 61;
  constant STATE_LESS_THAN (line 15) | const STATE_LESS_THAN = 1;
  constant STATE_SINGLE_QUOTE (line 16) | const STATE_SINGLE_QUOTE = 2;
  constant STATE_DOUBLE_QUOTE (line 17) | const STATE_DOUBLE_QUOTE = 3;
  type Attribute (line 19) | interface Attribute {
  type Element (line 26) | interface Element {
  function parseXmlDeclaration (line 36) | function parseXmlDeclaration(buffer: Buffer): Attribute[] {
  function parseAttrs (line 52) | function parseAttrs(string: string): Attribute[] {
  function decodeEntities (line 115) | function decodeEntities(string: string): string {
  function encodeEntities (line 148) | function encodeEntities(string: string): string {
  function parseXml (line 159) | function parseXml(string: string): Element {

FILE: lib/xmpp-client.ts
  function encodeBase64 (line 7) | function encodeBase64(str: string): string {
  function decodeBase64 (line 11) | function decodeBase64(str: string): string {
  function detectStreamTag (line 15) | function detectStreamTag(data: string): number {
  function xmppStream (line 23) | function xmppStream<T>(
  constant INT_1 (line 78) | const INT_1 = Buffer.from([0, 0, 0, 1]);
  function saltPassword (line 86) | function saltPassword(
  constant STATUS_RESTART_STREAM (line 240) | const STATUS_RESTART_STREAM = 1;
  constant STATUS_STARTTLS (line 241) | const STATUS_STARTTLS = 2;
  function upgradeTls (line 286) | function upgradeTls(socket: net.Socket, host: string): Promise<tls.TLSSo...
  type XmppClientOptions (line 296) | interface XmppClientOptions {
  class XmppClient (line 305) | class XmppClient extends EventEmitter {
    method constructor (line 315) | private constructor() {
    method connect (line 324) | static async connect(opts: XmppClientOptions): Promise<XmppClient> {
    method close (line 364) | close(): void {
    method ref (line 371) | ref(): void {
    method unref (line 375) | unref(): void {
    method host (line 379) | get host(): string {
    method username (line 383) | get username(): string {
    method resource (line 387) | get resource(): string {
    method _onData (line 391) | private _onData(chunk: Buffer): void {
    method _onError (line 425) | private _onError(err: Error): void {
    method send (line 431) | send(msg: string): void {
    method sendIqStanza (line 435) | sendIqStanza(

FILE: seed/device-page-tr098.jsx
  constant FIVE_MINUTES (line 97) | const FIVE_MINUTES = 5 * 60 * 1000;
  constant ONE_DAY (line 98) | const ONE_DAY = 24 * 60 * 60 * 1000;

FILE: seed/device-page-tr181.jsx
  constant FIVE_MINUTES (line 93) | const FIVE_MINUTES = 5 * 60 * 1000;
  constant ONE_DAY (line 94) | const ONE_DAY = 24 * 60 * 60 * 1000;

FILE: seed/overview-page.jsx
  constant FIVE_MINUTES (line 6) | const FIVE_MINUTES = 5 * 60 * 1000;
  constant ONE_DAY (line 7) | const ONE_DAY = 24 * 60 * 60 * 1000;

FILE: seed/provisions.d.ts
  type Timestamps (line 1) | interface Timestamps {
  type Values (line 10) | interface Values {
  type ParameterWrapper (line 19) | interface ParameterWrapper extends Iterable<ParameterWrapper> {
  type DateConstructor (line 49) | interface DateConstructor {

FILE: seed/views.d.ts
  type Signal (line 1) | interface Signal<T = any> {
  type StateSignal (line 5) | interface StateSignal<T = any> extends Signal<T> {
  type ComputedSignal (line 10) | interface ComputedSignal<T = any> extends Signal<T> {}
  type ConstSignal (line 13) | interface ConstSignal<T = any> extends Signal<T> {}
  type SignalConstructors (line 15) | interface SignalConstructors {
  type ViewElement (line 23) | type ViewElement = ViewNode | string | number | Signal | ViewElement[];
  class ViewNode (line 25) | class ViewNode {
  type SignalizedViewNode (line 31) | interface SignalizedViewNode {

FILE: test/mocks/store.ts
  function getClockSkew (line 13) | function getClockSkew(): number {
  type MockHandler (line 18) | type MockHandler = (options: XhrRequestOptions) => unknown | Promise<unk...
  type RequestRecord (line 24) | interface RequestRecord {
  type XhrRequestOptions (line 32) | interface XhrRequestOptions {
  type MockXhr (line 42) | interface MockXhr {
  function parseQueryParams (line 48) | function parseQueryParams(url: string): Record<string, string> {
  function evaluate (line 63) | function evaluate(
  function filterData (line 83) | function filterData(data: unknown[], filterStr: string | undefined): unk...
  function xhrRequest (line 96) | async function xhrRequest(options: XhrRequestOptions): Promise<unknown> {
  function mockRegisterHandler (line 131) | function mockRegisterHandler(handler: MockHandler): void {
  function mockClearHandlers (line 135) | function mockClearHandlers(): void {
  function mockGetRequestLog (line 140) | function mockGetRequestLog(): RequestRecord[] {
  function mockClearRequestLog (line 144) | function mockClearRequestLog(): void {
  function mockUrlHandler (line 148) | function mockUrlHandler(
  function mockCountHandler (line 165) | function mockCountHandler(
  function mockFetchHandler (line 203) | function mockFetchHandler(

FILE: test/pagination.ts
  constant VALUES (line 12) | const VALUES = [null, -1, false, "a"];
  constant PARAMS (line 13) | const PARAMS = ["param1", "param2"];
  function query (line 17) | async function query(filter: string): Promise<{ id: string }[]> {
  function getAllSortOrders (line 46) | function getAllSortOrders(columns: string[]): Array<Record<string, numbe...
  function testPaginate (line 72) | async function testPaginate(

FILE: test/reactive-store.ts
  type FetchedRegion (line 44) | interface FetchedRegion {
  type ResourceCache (line 49) | interface ResourceCache {
  function getCacheState (line 56) | function getCacheState(resource: string): {
  function clearStores (line 89) | function clearStores(): void {
  function forcePruneCache (line 93) | function forcePruneCache(resource: string): void {

FILE: test/signals.ts
  class Counter (line 84) | class Counter extends StateSignal<number> {
    method increment (line 85) | increment(): void {

FILE: test/synth.ts
  function isFalse (line 13) | function isFalse(expr: Expression): boolean {
  constant STRING_VALUES (line 17) | const STRING_VALUES = [null, "", "a", "ab", "ab10", "ab-10"];
  constant DECIMAL_VALUES (line 18) | const DECIMAL_VALUES = [null, 0, -10, 10];
  function query (line 22) | async function query(filter: string): Promise<Set<number>> {
  function setsEqual (line 46) | function setsEqual(set1: Set<number>, set2: Set<number>): boolean {
  function getPermutations (line 52) | function getPermutations(...arrs: any[][]): any[][] {

FILE: ui/app.ts
  type Window (line 31) | interface Window {
  function pagify (line 63) | function pagify(pageName, page): RouteResolver {

FILE: ui/autocomplete-compnent.ts
  type AutocompleteCallback (line 1) | type AutocompleteCallback = (
  class Autocomplete (line 6) | class Autocomplete {
    method constructor (line 15) | public constructor(callback: AutocompleteCallback) {
    method attach (line 31) | public attach(el: HTMLInputElement): void {
    method reposition (line 76) | public reposition(): void {
    method hide (line 89) | private hide(): void {
    method update (line 103) | private update(): void {

FILE: ui/change-password-component.ts
  type Attrs (line 6) | interface Attrs {

FILE: ui/code-editor-component.ts
  type Attrs (line 5) | interface Attrs {

FILE: ui/components.ts
  type MC (line 45) | interface MC extends Static {
  function contextFn (line 86) | function contextFn(context, ...argumentsList): Vnode {
  function applyContext (line 92) | function applyContext(vnode, parentContext): void {
  function contextifyComponent (line 106) | function contextifyComponent(component: ComponentTypes): ComponentTypes {

FILE: ui/components/all-parameters.ts
  function escapeRegExp (line 12) | function escapeRegExp(str): string {
  type Parameter (line 16) | interface Parameter {
  type Attrs (line 52) | interface Attrs {

FILE: ui/components/container.ts
  type Attrs (line 35) | interface Attrs {

FILE: ui/components/loading.ts
  function apply (line 8) | function apply(vnode: VnodeDOM): void {

FILE: ui/components/overview-dot.ts
  constant CHARTS (line 6) | const CHARTS = overview.charts;

FILE: ui/components/parameter-list.ts
  type Attrs (line 7) | interface Attrs {

FILE: ui/components/parameter-table.ts
  type Attrs (line 10) | interface Attrs {

FILE: ui/components/ping.ts
  constant REFRESH_INTERVAL (line 5) | const REFRESH_INTERVAL = 3000;

FILE: ui/components/summon-button.ts
  type Attrs (line 10) | interface Attrs {

FILE: ui/components/tags.ts
  type Attrs (line 11) | interface Attrs {

FILE: ui/config-functions.ts
  type Config (line 1) | interface Config {
  type Diff (line 6) | interface Diff {
  function flattenConfig (line 11) | function flattenConfig(config: Record<string, unknown>): any {
  function orderKeys (line 27) | function orderKeys(config: any): number {
  function structureConfig (line 55) | function structureConfig(config: Config[]): any {
  function diffConfig (line 111) | function diffConfig(

FILE: ui/config-page.ts
  type ValidationErrors (line 17) | interface ValidationErrors {
  function putActionHandler (line 21) | function putActionHandler(action, _object, isNew?): Promise<ValidationEr...
  function escapeRegExp (line 90) | function escapeRegExp(str): string {
  function init (line 94) | function init(): Promise<Record<string, unknown>> {
  function renderTable (line 109) | function renderTable(confsResponse, searchString): Children {

FILE: ui/config.ts
  type Filters (line 5) | type Filters = { label: string; parameter: Expression; type: string }[];
  type pageSize (line 6) | type pageSize = number;
  type overview (line 7) | type overview = {
  type Index (line 24) | type Index = {
  type NestedRecord (line 32) | type NestedRecord = { [k: string]: Expression | NestedRecord };

FILE: ui/datalist.ts
  function hash (line 6) | function hash(str: string): number {
  function getDatalistId (line 16) | function getDatalistId(options: string[]): string {

FILE: ui/device-page.ts
  function init (line 9) | function init(
  type Attrs (line 28) | interface Attrs {

FILE: ui/devices-page.ts
  function init (line 55) | function init(args: Record<string, unknown>): Promise<Attrs> {
  function renderActions (line 78) | function renderActions(selected: Set<string>): Children {
  type Attrs (line 261) | interface Attrs {
  function showMore (line 273) | function showMore(): void {
  function onFilterChanged (line 279) | function onFilterChanged(filter: Expression): void {
  function onSortChange (line 297) | function onSortChange(sortedAttrs): void {

FILE: ui/drawer-component.ts
  function renderStagingSpv (line 26) | function renderStagingSpv(task: StageTask, queueFunc, cancelFunc): Child...
  function renderStagingDownload (line 97) | function renderStagingDownload(task: StageTask): Children {
  function renderStaging (line 186) | function renderStaging(staging: Set<StageTask>): Child[] {
  function renderQueue (line 240) | function renderQueue(queue: Set<QueueTask>): Child[] {
  function renderNotifications (line 397) | function renderNotifications(notifs): Child[] {
  function repositionNotifications (line 475) | function repositionNotifications(): void {
  function resizeDrawer (line 483) | function resizeDrawer(): void {

FILE: ui/dynamic-loader.ts
  function onError (line 8) | function onError(): void {
  function loadCodeMirror (line 22) | function loadCodeMirror(): Promise<void> {
  function loadYaml (line 38) | function loadYaml(): Promise<void> {

FILE: ui/faults-page.ts
  function deleteFaults (line 58) | async function deleteFaults(faults: Iterable<string>): Promise<void> {
  function init (line 70) | function init(
  function showMore (line 91) | function showMore(): void {
  function onFilterChanged (line 97) | function onFilterChanged(filter): void {
  function onSortChange (line 115) | function onSortChange(sortAttrs): void {

FILE: ui/files-page.ts
  function upload (line 66) | function upload(
  function init (line 104) | function init(
  function showMore (line 126) | function showMore(): void {
  function onFilterChanged (line 132) | function onFilterChanged(filter): void {
  function onSortChange (line 148) | function onSortChange(sortAttrs): void {

FILE: ui/filter-component.ts
  function parseFilter (line 24) | function parseFilter(resource: string, f: string): Expression {
  function splitFilter (line 63) | function splitFilter(filter: Expression): string[] {
  type Attrs (line 86) | interface Attrs {
  function onChange (line 98) | function onChange(): void {

FILE: ui/index-table-component.ts
  type Attribute (line 6) | interface Attribute {
  constant MAX_PAGE_SIZE (line 12) | const MAX_PAGE_SIZE = 200;
  function getExcerpt (line 14) | function getExcerpt(text: string, maxLength = 80, maxLines = 10): string...
  function renderTable (line 30) | function renderTable(

FILE: ui/layout.tsx
  function tsxComponent (line 17) | function tsxComponent<T>(
  function classNames (line 29) | function classNames(...classes: string[]): string {
  type Attrs (line 33) | interface Attrs {
  function setSidebarOpen (line 40) | function setSidebarOpen(open: boolean): void {

FILE: ui/login-page.tsx
  function init (line 8) | function init(
  function logIn (line 19) | function logIn(e: MouseEvent): boolean {
  function changePassword (line 33) | function changePassword(): void {

FILE: ui/long-text-component.ts
  function overflowed (line 11) | function overflowed(_vnode): void {

FILE: ui/notifications.ts
  type Notification (line 3) | interface Notification {
  function push (line 12) | function push(
  function dismiss (line 34) | function dismiss(n: Notification): void {
  function getNotifications (line 39) | function getNotifications(): Set<Notification> {

FILE: ui/overlay.ts
  type OverlayCallback (line 4) | type OverlayCallback = () => Children;
  type CloseCallback (line 5) | type CloseCallback = () => boolean;
  function open (line 10) | function open(
  function close (line 18) | function close(callback: OverlayCallback, force = true): boolean {
  function render (line 29) | function render(): Children {

FILE: ui/overview-page.ts
  constant GROUPS (line 9) | const GROUPS = overview.groups;
  constant CHARTS (line 10) | const CHARTS: typeof overview.charts = {};
  function queryCharts (line 16) | function queryCharts(charts: typeof overview.charts): typeof charts {
  function init (line 28) | function init(): Promise<{ charts: typeof overview.charts }> {
  type Attrs (line 38) | interface Attrs {

FILE: ui/permissions-page.ts
  function getExcerpt (line 46) | function getExcerpt(text: string, maxLength = 80, maxLines = 10): string...
  type ValidationErrors (line 82) | interface ValidationErrors {
  function putActionHandler (line 86) | function putActionHandler(action, _object, isNew): Promise<ValidationErr...
  function init (line 182) | function init(
  function showMore (line 203) | function showMore(): void {
  function onFilterChanged (line 209) | function onFilterChanged(filter): void {
  function onSortChange (line 228) | function onSortChange(sortAttrs): void {

FILE: ui/pie-chart-component.ts
  function drawChart (line 5) | function drawChart(chartData: Attrs["chart"]): Children {
  type Attrs (line 136) | interface Attrs {

FILE: ui/presets-page.ts
  type ValidationErrors (line 48) | interface ValidationErrors {
  function getExcerpt (line 52) | function getExcerpt(text: string, maxLength = 80, maxLines = 10): string...
  function putActionHandler (line 68) | function putActionHandler(action, _object, isNew): Promise<ValidationErr...
  function init (line 152) | function init(
  function showMore (line 174) | function showMore(): void {
  function onFilterChanged (line 180) | function onFilterChanged(filter): void {
  function onSortChange (line 206) | function onSortChange(sortAttrs): void {

FILE: ui/provisions-page.ts
  type ValidationErrors (line 42) | interface ValidationErrors {
  function putActionHandler (line 46) | function putActionHandler(action, _object, isNew): Promise<ValidationErr...
  function init (line 121) | function init(
  function showMore (line 150) | function showMore(): void {
  function onFilterChanged (line 156) | function onFilterChanged(filter): void {
  function onSortChange (line 172) | function onSortChange(sortAttrs): void {

FILE: ui/put-form-component.ts
  function createField (line 16) | function createField(current, attr, focus): Children {
  type Attrs (line 175) | interface Attrs {

FILE: ui/reactive-store.ts
  function evaluate (line 21) | function evaluate(
  type BookmarkData (line 41) | type BookmarkData = Record<string, null | boolean | number | string>;
  type QueryState (line 43) | interface QueryState<T> {
  type FetchedRegion (line 49) | interface FetchedRegion {
  type CachedCount (line 55) | interface CachedCount {
  type CachedBookmark (line 60) | interface CachedBookmark {
  type ResourceCache (line 65) | interface ResourceCache {
  class Bookmark (line 72) | class Bookmark {
    method constructor (line 73) | constructor(
    method applySkip (line 79) | applySkip(filter: Expression): Expression {
    method applyLimit (line 85) | applyLimit(filter: Expression): Expression {
  class QuerySignal (line 91) | class QuerySignal<T> extends SignalBase<QueryState<T>> {
    method constructor (line 95) | constructor(initialValue: T) {
    method get (line 105) | get(): QueryState<T> {
    method _peek (line 112) | _peek(): QueryState<T> {
    method _update (line 117) | _update(value: T, timestamp: number, loading: boolean): void {
    method _markSinksDirty (line 129) | private _markSinksDirty(): void {
    method _markSinksChecking (line 145) | private _markSinksChecking(
  method [Symbol.dispose] (line 165) | [Symbol.dispose](): void {
  function compareFunction (line 172) | function compareFunction(
  function getObjectId (line 208) | function getObjectId(resourceType: string, obj: unknown): string {
  type FetchQueryEntry (line 215) | interface FetchQueryEntry {
  type CountQueryEntry (line 221) | interface CountQueryEntry {
  type BookmarkQueryEntry (line 226) | interface BookmarkQueryEntry {
  class ResourceStore (line 233) | class ResourceStore {
    method constructor (line 243) | constructor(private resourceType: string) {
    method fetch (line 259) | fetch(
    method count (line 302) | count(filter: Expression, freshness: number): QuerySignal<number> {
    method createBookmark (line 337) | createBookmark(
    method getCombinedFilter (line 386) | private getCombinedFilter(minTimestamp: number): Expression {
    method checkCoverage (line 395) | private checkCoverage(
    method findMatchingObjects (line 421) | private findMatchingObjects(
    method addFetchedRegion (line 439) | private addFetchedRegion(filter: Expression, timestamp: number): void {
    method triggerFetchRefresh (line 469) | private triggerFetchRefresh(
    method triggerCountRefresh (line 531) | private triggerCountRefresh(
    method triggerBookmarkRefresh (line 576) | private triggerBookmarkRefresh(
    method invalidate (line 629) | invalidate(timestamp: number): void {
    method onQueryDisposed (line 671) | private onQueryDisposed(type: string, key: string): void {
    method pruneCache (line 684) | private pruneCache(): void {
  function getStore (line 743) | function getStore(resource: string): ResourceStore {
  function applyDefaultSort (line 752) | function applyDefaultSort(
  function fetch (line 765) | function fetch(
  function count (line 778) | function count(
  function createBookmark (line 787) | function createBookmark(
  function invalidate (line 808) | function invalidate(timestamp: number): void {

FILE: ui/signals.ts
  type ComputedState (line 4) | const enum ComputedState {
  function createSafeProxy (line 12) | function createSafeProxy<T extends object>(target: T): T {
  function registerDependency (line 47) | function registerDependency(source: SignalBase<unknown>): void {
  function registerCleanup (line 54) | function registerCleanup(cleanup: () => void): void {
  function runCleanups (line 60) | function runCleanups(signal: ComputedSignal<unknown>): void {
  type Sink (line 68) | type Sink = ComputedSignal<unknown> | Watcher;
  function markSinksChecking (line 70) | function markSinksChecking(sinks: Set<WeakRef<Sink>>): void {
  function markSinksDirty (line 92) | function markSinksDirty(sinks: Set<WeakRef<Sink>>): void {
  class ConstSignal (line 126) | class ConstSignal<T> extends SignalBase<T> {
    method constructor (line 129) | constructor(value: T) {
    method get (line 139) | get(): T {
  method [Symbol.dispose] (line 144) | [Symbol.dispose](): void {
  class StateSignal (line 151) | class StateSignal<T> extends SignalBase<T> {
    method constructor (line 154) | constructor(initialValue: T) {
    method get (line 165) | get(): T {
    method set (line 171) | set(newValue: T): void {
  method [Symbol.dispose] (line 178) | [Symbol.dispose](): void {
  class ComputedSignal (line 186) | class ComputedSignal<T> extends SignalBase<T> {
    method constructor (line 199) | constructor(callback: () => T) {
    method get (line 211) | get(): T {
    method _isValid (line 225) | _isValid(): boolean {
    method _recompute (line 242) | private _recompute(): T {
  method [Symbol.dispose] (line 280) | [Symbol.dispose](): void {
  class Watcher (line 307) | class Watcher implements Disposable {
    method constructor (line 314) | constructor(notify: () => void) {
    method watch (line 320) | watch(...signals: SignalBase<unknown>[]): void {
    method unwatch (line 329) | unwatch(...signals: SignalBase<unknown>[]): void {
    method getPending (line 338) | getPending(): SignalBase<unknown>[] {
    method _notify (line 350) | _notify(): void {
  method [Symbol.dispose] (line 356) | [Symbol.dispose](): void {
  class SafeConstSignal (line 368) | class SafeConstSignal<T> extends ConstSignal<T> {
    method constructor (line 373) | constructor(value: T) {
  method [Symbol.hasInstance] (line 369) | static [Symbol.hasInstance](instance: unknown): boolean {
  class SafeStateSignal (line 379) | class SafeStateSignal<T> extends StateSignal<T> {
    method constructor (line 384) | constructor(initialValue: T) {
  method [Symbol.hasInstance] (line 380) | static [Symbol.hasInstance](instance: unknown): boolean {
  class SafeComputedSignal (line 390) | class SafeComputedSignal<T> extends ComputedSignal<T> {
    method constructor (line 395) | constructor(callback: () => T) {
  method [Symbol.hasInstance] (line 391) | static [Symbol.hasInstance](instance: unknown): boolean {
  method [Symbol.hasInstance] (line 405) | [Symbol.hasInstance](instance: unknown): boolean {
  function setTimeout (line 413) | function setTimeout<TArgs extends unknown[]>(
  function setInterval (line 440) | function setInterval<TArgs extends unknown[]>(

FILE: ui/skewed-date.ts
  function getClockSkew (line 1) | function getClockSkew(): number {
  class SkewedDate (line 5) | class SkewedDate extends Date {
    method constructor (line 6) | constructor(...args: unknown[]) {
    method now (line 14) | static override now(): number {

FILE: ui/smart-query.ts
  function getLabels (line 113) | function getLabels(resource: string): string[] {
  function queryNumber (line 118) | function queryNumber(param: Expression, value: string): Expression {
  function queryTimestamp (line 134) | function queryTimestamp(param: Expression, value: string): Expression {
  function queryString (line 150) | function queryString(param: Expression, value: string): Expression {
  function queryStringCaseSensitive (line 158) | function queryStringCaseSensitive(
  function queryStringMonoCase (line 165) | function queryStringMonoCase(param: Expression, value: string): Expressi...
  function queryMac (line 180) | function queryMac(param: Expression, value: string): Expression {
  function queryMacWildcard (line 214) | function queryMacWildcard(param: Expression, value: string): Expression {
  function queryTag (line 243) | function queryTag(tag: string): Expression {
  function getTip (line 251) | function getTip(resource: string, label: string): string {
  function unpack (line 295) | function unpack(

FILE: ui/store.ts
  function evaluate (line 24) | function evaluate(
  type Resources (line 62) | interface Resources {
  class QueryResponse (line 92) | class QueryResponse {
    method fulfilled (line 93) | public get fulfilled(): number {
    method fulfilling (line 98) | public get fulfilling(): boolean {
    method value (line 103) | public get value(): any {
  function checkConnection (line 109) | function checkConnection(): void {
  function xhrRequest (line 196) | async function xhrRequest(
  function unpackExpression (line 246) | function unpackExpression(exp: Expression): Expression {
  function count (line 250) | function count(resourceType: string, filter: Expression): QueryResponse {
  function compareFunction (line 262) | function compareFunction(sort: {
  function findMatches (line 298) | function findMatches(resourceType, filter, sort, limit): any[] {
  function fetch (line 310) | function fetch(
  function fulfill (line 347) | function fulfill(accessTimestamp: number): void {
  function getTimestamp (line 565) | function getTimestamp(): number {
  function setTimestamp (line 569) | function setTimestamp(t: number): void {
  function postTasks (line 577) | function postTasks(
  function updateTags (line 610) | function updateTags(
  function deleteResource (line 621) | function deleteResource(
  function putResource (line 631) | function putResource(
  function queryConfig (line 645) | function queryConfig(pattern = "%"): Promise<any[]> {
  function resourceExists (line 658) | function resourceExists(resource: string, id: string): Promise<number> {
  function evaluateExpression (line 689) | function evaluateExpression(
  function changePassword (line 696) | function changePassword(
  function logIn (line 711) | function logIn(
  function logOut (line 724) | function logOut(): Promise<void> {
  function ping (line 731) | function ping(host: string): Promise<PingResult> {

FILE: ui/tailwind-utility-components.ts
  type DialogAttrs (line 39) | interface DialogAttrs {
  method view (line 47) | view(vnode) {
  type DialogOverlayAttrs (line 60) | interface DialogOverlayAttrs {
  method view (line 66) | view(vnode) {
  type TransitionRootAttrs (line 79) | interface TransitionRootAttrs {
  method view (line 92) | view(vnode: Vnode<TransitionRootAttrs>) {
  type TransitionChildAttrs (line 114) | interface TransitionChildAttrs {
  function updateCssClasses (line 128) | function updateCssClasses(vnode: VnodeDOM<TransitionChildAttrs>): void {
  method view (line 161) | view(vnode: Vnode<TransitionChildAttrs>) {
  method oncreate (line 168) | oncreate(vnode: VnodeDOM<TransitionChildAttrs>) {
  method onupdate (line 172) | onupdate(vnode: VnodeDOM<TransitionChildAttrs>) {
  type IconAttrs (line 178) | interface IconAttrs {
  method view (line 185) | view(vnode) {

FILE: ui/task-queue.ts
  type QueueTask (line 6) | interface QueueTask extends Task {
  type StageTask (line 11) | interface StageTask extends Task {
  constant MAX_QUEUE (line 15) | const MAX_QUEUE = 100;
  function canQueue (line 20) | function canQueue(tasks: QueueTask[]): boolean {
  function queueTask (line 26) | function queueTask(...tasks: QueueTask[]): void {
  function deleteTask (line 39) | function deleteTask(task: QueueTask): void {
  function getQueue (line 43) | function getQueue(): Set<QueueTask> {
  function clear (line 47) | function clear(): void {
  function getStaging (line 51) | function getStaging(): Set<StageTask> {
  function clearStaging (line 55) | function clearStaging(): void {
  function stageSpv (line 59) | function stageSpv(task: StageTask): void {
  function stageDownload (line 68) | function stageDownload(task: StageTask): void {
  function commit (line 77) | function commit(

FILE: ui/timeago.ts
  constant UNITS (line 1) | const UNITS = {
  function timeAgo (line 10) | function timeAgo(dtime: number): string {

FILE: ui/ui-config-component.ts
  function putActionHandler (line 9) | function putActionHandler(prefix: string[], dataYaml: string): Promise<a...
  type Attrs (line 70) | interface Attrs {

FILE: ui/users-page.ts
  type ValidationErrors (line 42) | interface ValidationErrors {
  function putActionHandler (line 46) | function putActionHandler(action, _object, isNew): Promise<ValidationErr...
  function init (line 137) | function init(
  function showMore (line 159) | function showMore(): void {
  function onFilterChanged (line 165) | function onFilterChanged(filter): void {
  function onSortChange (line 184) | function onSortChange(sortAttrs): void {

FILE: ui/views-page.ts
  constant PAGE_SIZE (line 15) | const PAGE_SIZE = config.pageSize || 10;
  type ValidationErrors (line 42) | interface ValidationErrors {
  function putActionHandler (line 46) | function putActionHandler(action, _object, isNew): Promise<ValidationErr...
  function init (line 120) | function init(
  function showMore (line 146) | function showMore(): void {
  function onFilterChanged (line 152) | function onFilterChanged(filter): void {
  function onSortChange (line 166) | function onSortChange(sortAttrs): void {

FILE: ui/views.ts
  type ViewElement (line 20) | type ViewElement =
  class ViewNode (line 27) | class ViewNode {
    method constructor (line 31) | constructor(
  type SignalizedViewNode (line 45) | interface SignalizedViewNode {
  function toSignal (line 52) | function toSignal<T>(value: T | SignalBase<T>): SignalBase<T> {
  function signalizeNode (line 58) | function signalizeNode(node: ViewNode): SignalizedViewNode {
  function doCount (line 71) | function doCount(node: SignalizedViewNode): ViewElement {
  function doFetch (line 96) | function doFetch(node: SignalizedViewNode): ViewElement {
  function doTask (line 119) | function doTask(node: SignalizedViewNode): ViewElement {
  function doNotify (line 166) | function doNotify(node: SignalizedViewNode): ViewElement {
  function doDelete (line 180) | function doDelete(node: SignalizedViewNode): ViewElement {
  function doYamlStringify (line 202) | function doYamlStringify(node: SignalizedViewNode): ViewElement {
  function doUpdateTags (line 212) | function doUpdateTags(node: SignalizedViewNode): ViewElement {
  function doPing (line 234) | function doPing(node: SignalizedViewNode): ViewElement {
  function initView (line 256) | function initView(context: RenderContext, node: ViewElement): ViewElement {
  type SetTimeout (line 300) | type SetTimeout = typeof setTimeout;
  type DateConstructorLike (line 302) | type DateConstructorLike = typeof globalThis.Date;
  type ViewFunc (line 304) | type ViewFunc = (
  class RenderContext (line 311) | class RenderContext {
    method constructor (line 315) | constructor(clone?: RenderContext) {
    method getView (line 325) | getView(name: string): ViewFunc {
    method pushViews (line 331) | pushViews(_views: Record<string, ViewFunc>): RenderContext {
    method popView (line 339) | popView(name: string): RenderContext {
    method getDeferred (line 347) | getDeferred(): (ViewNode | SignalBase | any)[] {
    method popDeferred (line 352) | popDeferred(): RenderContext {
    method pushDeferred (line 358) | pushDeferred(deferred: (ViewNode | SignalBase | any)[]): RenderContext {
  function renderNode (line 365) | function renderNode(node: ViewElement): ReturnType<typeof m> {

FILE: ui/virtual-parameters-page.ts
  type ValidationErrors (line 42) | interface ValidationErrors {
  function putActionHandler (line 46) | function putActionHandler(action, _object, isNew): Promise<ValidationErr...
  function init (line 121) | function init(
  function showMore (line 150) | function showMore(): void {
  function onFilterChanged (line 156) | function onFilterChanged(filter): void {
  function onSortChange (line 172) | function onSortChange(sortAttrs): void {

FILE: ui/wizard-page.ts
  function init (line 5) | async function init(): Promise<Record<string, unknown>> {