@opra/common 0.5.0 → 0.7.0

package/esm/schema/type-helpers/extend-type.helper.js

@@ -0,0 +1,59 @@
+import * as Optionals from '@opra/optionals';
+import { DATATYPE_METADATA, MAPPED_TYPE_METADATA } from '../constants.js';
+import { applyMixins, inheritPropertyInitializers } from './mixin.utils.js';
+export function PickType(classRef, keys) {
+    return ExtendType(classRef, classRef, { pickKeys: keys });
+}
+export function OmitType(classRef, keys) {
+    return ExtendType(classRef, classRef, { omitKeys: keys });
+}
+function ExtendType(classRef, orgClassRef, options) {
+    const pickKeys = options.pickKeys && options.pickKeys.map(x => String(x).toLowerCase());
+    const omitKeys = options.omitKeys && options.omitKeys.map(x => String(x).toLowerCase());
+    const isInheritedPredicate = (propertyName) => {
+        if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
+            return false;
+        if (pickKeys)
+            return pickKeys.includes(propertyName.toLowerCase());
+        return true;
+    };
+    // const isRequiredPredicate = (propertyName: string): boolean | undefined => {
+    //   if (options.requiredKeys && options.requiredKeys.includes(propertyName as RequiredKey))
+    //     return true;
+    //   if (options.partialKeys && options.partialKeys.includes(propertyName as PartialKey))
+    //     return false;
+    //   return;
+    // };
+    class MappedClass {
+        constructor() {
+            inheritPropertyInitializers(this, classRef, isInheritedPredicate);
+        }
+    }
+    applyMixins(MappedClass, classRef);
+    const mappedTypeMetadata = [];
+    const m = Reflect.getOwnMetadata(DATATYPE_METADATA, classRef);
+    if (m) {
+        if (!(m.kind === 'ComplexType'))
+            throw new TypeError(`Class "${classRef}" is not a ComplexType`);
+        const meta = {
+            type: classRef
+        };
+        if (options.pickKeys)
+            meta.pick = options.pickKeys;
+        if (options.omitKeys)
+            meta.omit = options.omitKeys;
+        mappedTypeMetadata.push(meta);
+    }
+    else
+        throw new TypeError(`Class "${classRef}" doesn't have datatype metadata information`);
+    if (Optionals.SqbConnect) {
+        const { Entity, EntityMetadata } = Optionals.SqbConnect;
+        const srcMeta = Entity.getMetadata(classRef);
+        if (srcMeta) {
+            const trgMeta = EntityMetadata.define(MappedClass);
+            EntityMetadata.mixin(trgMeta, srcMeta, k => isInheritedPredicate(k));
+        }
+    }
+    Reflect.defineMetadata(MAPPED_TYPE_METADATA, mappedTypeMetadata, MappedClass);
+    return MappedClass;
+}

package/esm/schema/type-helpers/mixin-type.helper.d.ts

@@ -0,0 +1,2 @@
+import { Class } from 'ts-gems';
+export declare function MixinType<A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, c4?: Class<A4, I4, S4>): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;

package/esm/schema/type-helpers/mixin-type.helper.js

@@ -0,0 +1,41 @@
+import * as Optionals from '@opra/optionals';
+import { DATATYPE_METADATA, MAPPED_TYPE_METADATA } from '../constants.js';
+import { applyMixins, inheritPropertyInitializers } from './mixin.utils.js';
+export function MixinType(c1, c2, c3, c4) {
+    const clasRefs = [...arguments].filter(x => !!x);
+    if (!clasRefs.length)
+        throw new TypeError('You must provide base classeses');
+    if (clasRefs.length === 1)
+        return clasRefs[0];
+    class MappedClass {
+        constructor() {
+            for (const c of clasRefs)
+                inheritPropertyInitializers(this, c);
+        }
+    }
+    const mappedTypeMetadata = [];
+    for (const c of clasRefs) {
+        const m = Reflect.getOwnMetadata(DATATYPE_METADATA, c);
+        if (m) {
+            if (!(m.kind === 'ComplexType'))
+                throw new TypeError(`Class "${c}" is not a ComplexType`);
+            mappedTypeMetadata.push({
+                type: c
+            });
+        }
+        else if (Reflect.hasMetadata(MAPPED_TYPE_METADATA, c)) {
+            const mtm = Reflect.getMetadata(MAPPED_TYPE_METADATA, c);
+            if (mtm)
+                mappedTypeMetadata.push(...mtm);
+        }
+        else
+            throw new TypeError(`Class "${c}" doesn't have datatype metadata information`);
+        applyMixins(MappedClass, c);
+    }
+    if (Optionals.SqbConnect) {
+        const { Entity } = Optionals.SqbConnect;
+        Entity.mixin(MappedClass, ...clasRefs);
+    }
+    Reflect.defineMetadata(MAPPED_TYPE_METADATA, mappedTypeMetadata, MappedClass);
+    return MappedClass;
+}

package/esm/schema/type-helpers/mixin.utils.d.ts

@@ -0,0 +1,3 @@
+import { Type } from 'ts-gems';
+export declare function applyMixins(derivedCtor: any, baseCtor: any, filter?: (k: string) => boolean): void;
+export declare function inheritPropertyInitializers(target: Record<string, any>, sourceClass: Type, isPropertyInherited?: (key: string) => boolean): void;

package/esm/schema/type-helpers/mixin.utils.js

@@ -0,0 +1,27 @@
+export function applyMixins(derivedCtor, baseCtor, filter) {
+    for (const k of Object.getOwnPropertyNames(baseCtor.prototype)) {
+        if ((k === 'constructor' || k === '__proto__' || k === 'toJSON' || k === 'toString') ||
+            filter && !filter(k))
+            continue;
+        Object.defineProperty(derivedCtor.prototype, k, Object.getOwnPropertyDescriptor(baseCtor.prototype, k) ||
+            Object.create(null));
+    }
+}
+export function inheritPropertyInitializers(target, sourceClass, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+isPropertyInherited = (key) => true) {
+    try {
+        const tempInstance = new sourceClass();
+        const propertyNames = Object.getOwnPropertyNames(tempInstance);
+        propertyNames
+            .filter((propertyName) => typeof tempInstance[propertyName] !== 'undefined' &&
+            typeof target[propertyName] === 'undefined')
+            .filter((propertyName) => isPropertyInherited(propertyName))
+            .forEach((propertyName) => {
+            target[propertyName] = tempInstance[propertyName];
+        });
+    }
+    catch {
+        //
+    }
+}

package/esm/{types.d.ts → schema/types.d.ts}

@@ -1,7 +1,14 @@
-import { Builtin, DeepPickWritable } from 'ts-gems';
+import { Builtin, DeepPickWritable, Type } from 'ts-gems';
 export declare type PartialInput<T> = DeepNullablePartial<DeepPickWritable<T>>;
 export declare type PartialOutput<T> = DeepNullablePartial<T>;
 declare type DeepNullablePartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullablePartial<U>> : T extends (infer U)[] ? DeepNullablePartial<U>[] : {
     [P in keyof T]?: DeepNullablePartial<Exclude<T[P], undefined>> | null;
 };
+export declare type Thunk<T> = T | (() => T);
+export declare type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
+export declare type TypeThunk<T = any> = Thunk<Type<T>>;
+export declare type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
+export declare type Named<T> = T & {
+    name: string;
+};
 export {};

package/esm/schema/types.js

@@ -0,0 +1 @@
+export {};

package/esm/schema/utils/class.utils.d.ts

@@ -0,0 +1,2 @@
+import { Type } from 'ts-gems';
+export declare function isConstructor(obj: any): obj is Type;

package/esm/schema/utils/class.utils.js

@@ -0,0 +1,4 @@
+export function isConstructor(obj) {
+    return typeof obj === 'function' &&
+        !!(obj.prototype && obj.prototype.constructor);
+}

package/esm/schema/utils/clone-object.util.d.ts

@@ -0,0 +1 @@
+export declare function cloneObject<T extends {}>(obj: T, jsonOnly?: boolean): T;

package/esm/schema/utils/clone-object.util.js

@@ -0,0 +1,14 @@
+import isPlainObject from 'putil-isplainobject';
+import merge from 'putil-merge';
+export function cloneObject(obj, jsonOnly) {
+    return merge({}, obj, {
+        deep: true,
+        clone: true,
+        filter: (source, key) => {
+            const v = source[key];
+            return v != null &&
+                !jsonOnly || (typeof v !== 'function' &&
+                (typeof v !== 'object' || isPlainObject(v) || Array.isArray(v)));
+        }
+    });
+}

package/esm/schema/utils/inspect.util.d.ts

@@ -0,0 +1,4 @@
+export declare const nodeInspectCustom: unique symbol;
+export declare const colorReset = "\u001B[0m";
+export declare const colorFgYellow = "\u001B[33m";
+export declare const colorFgMagenta = "\u001B[35m";

package/esm/schema/utils/inspect.util.js

@@ -0,0 +1,4 @@
+export const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
+export const colorReset = "\x1b[0m";
+export const colorFgYellow = "\x1b[33m";
+export const colorFgMagenta = "\x1b[35m";

package/esm/schema/utils/normalize-field-array.util.d.ts

@@ -0,0 +1,3 @@
+import { ComplexType } from '../implementation/data-type/complex-type.js';
+import type { OpraDocument } from '../implementation/opra-document.js';
+export declare function normalizeFieldArray(document: OpraDocument, dataType: ComplexType | undefined, fields: string[], parentPath?: string): string[];

package/esm/schema/utils/normalize-field-array.util.js

@@ -0,0 +1,40 @@
+import { ComplexType } from '../implementation/data-type/complex-type.js';
+import { pathToTree } from './path-to-tree.util.js';
+export function normalizeFieldArray(document, dataType, fields, parentPath = '') {
+    const fieldsTree = pathToTree(fields) || {};
+    return _normalizeFieldsList([], document, dataType, fieldsTree, '', parentPath, {
+        additionalFields: true
+    });
+}
+function _normalizeFieldsList(target, document, dataType, node, parentPath = '', actualPath = '', options) {
+    let curPath = '';
+    for (const k of Object.keys(node)) {
+        const nodeVal = node[k];
+        const prop = dataType?.fields.get(k);
+        if (!prop) {
+            curPath = parentPath ? parentPath + '.' + k : k;
+            if (!options?.additionalFields || (dataType && !dataType.additionalFields))
+                throw new TypeError(`Unknown field "${curPath}"`);
+            if (typeof nodeVal === 'object')
+                _normalizeFieldsList(target, document, undefined, nodeVal, curPath, actualPath, options);
+            else
+                target.push(curPath);
+            continue;
+        }
+        curPath = parentPath ? parentPath + '.' + prop.name : prop.name;
+        const propType = document.getDataType(prop.type || 'string');
+        if (typeof nodeVal === 'object') {
+            if (!(propType && propType instanceof ComplexType))
+                throw new TypeError(`"${(actualPath ? actualPath + '.' + curPath : curPath)}" is not a complex type and has no sub fields`);
+            if (target.findIndex(x => x === parentPath) >= 0)
+                continue;
+            target = _normalizeFieldsList(target, document, propType, nodeVal, curPath, actualPath, options);
+            continue;
+        }
+        if (target.findIndex(x => x.startsWith(curPath + '.')) >= 0) {
+            target = target.filter(x => !x.startsWith(curPath + '.'));
+        }
+        target.push(curPath);
+    }
+    return target;
+}

package/esm/schema/utils/path-to-tree.util.d.ts

@@ -0,0 +1,4 @@
+export interface ObjectTree {
+    [key: string]: boolean | ObjectTree;
+}
+export declare function pathToTree(arr: string[]): ObjectTree | undefined;

package/esm/schema/utils/path-to-tree.util.js

@@ -0,0 +1,22 @@
+const dotPattern = /^([^.]+)\.(.*)$/;
+export function pathToTree(arr) {
+    if (!arr.length)
+        return;
+    return _stringPathToObjectTree(arr, {});
+}
+function _stringPathToObjectTree(arr, target) {
+    for (const k of arr) {
+        const m = dotPattern.exec(k);
+        if (m) {
+            const key = m[1];
+            if (target[key] === true)
+                continue;
+            const sub = target[key] = typeof target[key] === 'object' ? target[key] : {};
+            _stringPathToObjectTree([m[2]], sub);
+        }
+        else {
+            target[k] = true;
+        }
+    }
+    return target;
+}

package/esm/schema/utils/string-compare.util.d.ts

@@ -0,0 +1 @@
+export declare function stringCompare(a: string, b: string): number;

package/esm/schema/utils/string-compare.util.js

@@ -0,0 +1,7 @@
+export function stringCompare(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}

package/esm/url/formats/boolean-format.d.ts

@@ -0,0 +1,5 @@
+import { Format } from './format.js';
+export declare class BooleanFormat extends Format {
+    parse(value: string): boolean;
+    stringify(value: any): string;
+}

package/esm/url/formats/boolean-format.js

@@ -0,0 +1,21 @@
+import { Format } from './format.js';
+const trueValues = ['true', 't', 'yes', 'y', '1'];
+const falseValues = ['false', 'f', 'no', 'n', '0'];
+export class BooleanFormat extends Format {
+    parse(value) {
+        if (value === '')
+            return true;
+        // noinspection SuspiciousTypeOfGuard
+        if (typeof value === 'boolean')
+            return value;
+        if (trueValues.includes(value.toLowerCase()))
+            return true;
+        if (falseValues.includes(value.toLowerCase()))
+            return false;
+        throw new TypeError(`"${value}" is not a valid boolean`);
+    }
+    stringify(value) {
+        return typeof value === 'boolean' ?
+            (value ? 'true' : 'false') : '';
+    }
+}

package/esm/url/formats/date-format.d.ts

@@ -0,0 +1,16 @@
+import { Format } from './format.js';
+export interface DateFormatOptions {
+    time?: boolean;
+    timeZone?: boolean;
+    min?: string;
+    max?: string;
+}
+export declare class DateFormat extends Format {
+    time: boolean;
+    timeZone: boolean;
+    min?: string;
+    max?: string;
+    constructor(options?: DateFormatOptions);
+    parse(value: string): string;
+    stringify(value: any): string;
+}

package/esm/url/formats/date-format.js

@@ -0,0 +1,44 @@
+/* eslint-disable max-len */
+import { Format } from './format.js';
+// noinspection RegExpUnnecessaryNonCapturingGroup
+const DATE_FORMAT_PATTERN = /^(\d{4})(?:-?(0[1-9]|1[012])(?:-?([123]0|[012][1-9]|31))?)?(?:[T ]?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
+export class DateFormat extends Format {
+    time;
+    timeZone;
+    min;
+    max;
+    constructor(options) {
+        super();
+        this.max = options?.max ? coerceToDateString(options.max) : undefined;
+        this.min = options?.min ? coerceToDateString(options.min) : undefined;
+        this.time = options?.time ?? true;
+        this.timeZone = options?.timeZone ?? true;
+    }
+    parse(value) {
+        const v = coerceToDateString(value, this.time, this.timeZone);
+        if (this.min != null && v < this.min)
+            throw new TypeError(`Value must be ${this.min} or greater.`);
+        if (this.max != null && v > this.max)
+            throw new TypeError(`Value must be ${this.max} or less.`);
+        return v;
+    }
+    stringify(value) {
+        return coerceToDateString(value, this.time, this.timeZone);
+    }
+}
+function coerceToDateString(value, time, timeZone) {
+    if (value === '' || value == null)
+        return '';
+    const m = value.match(DATE_FORMAT_PATTERN);
+    if (!m)
+        throw new TypeError(`"${value}" is not a valid date.`);
+    let v = m[1] + '-' + (m[2] || '01') + '-' + (m[3] || '01');
+    if (time) {
+        v += 'T' + (m[4] || '00') + ':' + (m[5] || '00') + ':' + (m[6] || '00') +
+            (m[7] ? '.' + m[7] : '');
+        if (timeZone)
+            v += m[8] ? 'Z' :
+                (m[9] ? (m[9] + (m[10] || '00') + ':' + (m[11] || '00')) : '');
+    }
+    return v;
+}

package/esm/url/formats/filter-format.d.ts

@@ -0,0 +1,6 @@
+import { Ast, Expression } from '../../filter/ast/index.js';
+import { Format } from './format.js';
+export declare class FilterFormat extends Format {
+    parse(value: string | Expression): object;
+    stringify(value: Ast): string;
+}

package/esm/url/formats/filter-format.js

@@ -0,0 +1,14 @@
+import { Expression } from '../../filter/ast/index.js';
+import { parseFilter } from '../../filter/parse.js';
+import { Format } from './format.js';
+export class FilterFormat extends Format {
+    parse(value) {
+        if (value instanceof Expression)
+            return value;
+        return parseFilter(value);
+    }
+    stringify(value) {
+        // @ts-ignore
+        return value ? '' + value : '';
+    }
+}

package/esm/url/formats/format.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class Format {
+    abstract parse(value: string): any;
+    abstract stringify(value: any): string;
+}

package/esm/url/formats/format.js

@@ -0,0 +1,2 @@
+export class Format {
+}

package/esm/url/formats/integer-format.d.ts

@@ -0,0 +1,9 @@
+import { NumberFormat, NumberFormatOptions } from './number-format.js';
+export interface IntegerFormatOptions extends NumberFormatOptions {
+    enum?: number[];
+}
+export declare class IntegerFormat extends NumberFormat {
+    enum?: number[];
+    constructor(options?: IntegerFormatOptions);
+    parse(value: string): number;
+}

package/esm/url/formats/integer-format.js

@@ -0,0 +1,16 @@
+import { NumberFormat } from './number-format.js';
+export class IntegerFormat extends NumberFormat {
+    enum;
+    constructor(options) {
+        super(options);
+        this.enum = options?.enum;
+    }
+    parse(value) {
+        const v = super.parse(value);
+        if (!Number.isInteger(v))
+            throw new TypeError(`"${value}" is not a valid integer`);
+        if (this.enum && !this.enum.includes(v))
+            throw new TypeError(`"${value}" is not one of allowed enum values (${this.enum}).`);
+        return v;
+    }
+}

package/esm/url/formats/number-format.d.ts

@@ -0,0 +1,12 @@
+import { Format } from './format.js';
+export interface NumberFormatOptions {
+    max?: number;
+    min?: number;
+}
+export declare class NumberFormat extends Format {
+    max?: number;
+    min?: number;
+    constructor(options?: NumberFormatOptions);
+    parse(value: string): number;
+    stringify(value: any): string;
+}

package/esm/url/formats/number-format.js

@@ -0,0 +1,24 @@
+import { Format } from './format.js';
+export class NumberFormat extends Format {
+    max;
+    min;
+    constructor(options) {
+        super();
+        this.max = options?.max;
+        this.min = options?.min;
+    }
+    parse(value) {
+        // noinspection SuspiciousTypeOfGuard
+        const v = typeof value === 'number' ? value : parseFloat(value);
+        if (isNaN(v))
+            throw new TypeError(`"${value}" is not a valid number`);
+        if (this.min != null && v < this.min)
+            throw new TypeError(`Value must be ${this.min} or greater.`);
+        if (this.max != null && v > this.max)
+            throw new TypeError(`Value must be ${this.max} or less.`);
+        return v;
+    }
+    stringify(value) {
+        return typeof value === 'number' ? '' + value : '';
+    }
+}

package/esm/url/formats/string-format.d.ts

@@ -0,0 +1,14 @@
+import { Format } from './format.js';
+export interface StringFormatOptions {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+}
+export declare class StringFormat extends Format {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+    constructor(options?: StringFormatOptions);
+    parse(value: string): string;
+    stringify(value: any): string;
+}

package/esm/url/formats/string-format.js

@@ -0,0 +1,24 @@
+import { Format } from './format.js';
+export class StringFormat extends Format {
+    maxLength;
+    minLength;
+    enum;
+    constructor(options) {
+        super();
+        this.maxLength = options?.maxLength;
+        this.minLength = options?.minLength;
+        this.enum = options?.enum;
+    }
+    parse(value) {
+        if (this.minLength != null && value.length < this.minLength)
+            throw new TypeError(`Value must be at least ${this.minLength} character${this.minLength > 1 ? 's' : ''} long.`);
+        if (this.maxLength != null && value.length > this.maxLength)
+            throw new TypeError(`Value can be up to ${this.maxLength} character${this.maxLength > 1 ? 's' : ''} long.`);
+        if (this.enum && !this.enum.includes(value))
+            throw new TypeError(`"${value}" is not one of allowed enum values (${this.enum}).`);
+        return value;
+    }
+    stringify(value) {
+        return value == null ? '' : '' + value;
+    }
+}

package/esm/url/index.d.ts

@@ -0,0 +1,5 @@
+export * from './opra-url.js';
+export * from './opra-url-path.js';
+export * from './opra-url-path-component.js';
+export * from './opra-url-search-params.js';
+export * from './utils/path-utils.js';

package/esm/url/index.js

@@ -0,0 +1,5 @@
+export * from './opra-url.js';
+export * from './opra-url-path.js';
+export * from './opra-url-path-component.js';
+export * from './opra-url-search-params.js';
+export * from './utils/path-utils.js';

package/esm/url/opra-url-path-component.d.ts

@@ -0,0 +1,15 @@
+declare const nodeInspectCustom: unique symbol;
+export declare type OpraURLPathComponentInit = {
+    resource: string;
+    key?: any;
+    typeCast?: string;
+};
+export declare class OpraURLPathComponent {
+    resource: string;
+    key?: any;
+    typeCast?: string;
+    constructor(init: OpraURLPathComponentInit);
+    toString(): string;
+    [nodeInspectCustom](): any;
+}
+export {};

package/esm/url/opra-url-path-component.js

@@ -0,0 +1,29 @@
+import { encodePathComponent } from './utils/path-utils.js';
+const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
+export class OpraURLPathComponent {
+    resource;
+    key;
+    typeCast;
+    constructor(init) {
+        this.resource = init.resource;
+        this.key = init.key;
+        this.typeCast = init.typeCast;
+    }
+    toString() {
+        const obj = encodePathComponent(this.resource, this.key, this.typeCast);
+        if (obj)
+            Object.setPrototypeOf(obj, OpraURLPathComponent.prototype);
+        return obj;
+    }
+    /* istanbul ignore next */
+    [nodeInspectCustom]() {
+        const out = {
+            resource: this.resource,
+        };
+        if (this.key != null)
+            out.key = this.key;
+        if (this.typeCast != null)
+            out.typeCast = this.typeCast;
+        return out;
+    }
+}

package/esm/url/opra-url-path.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { OpraURLPathComponent, OpraURLPathComponentInit } from './opra-url-path-component.js';
+declare const nodeInspectCustom: unique symbol;
+export declare class OpraURLPath extends EventEmitter {
+    private _entries;
+    constructor(...components: (OpraURLPathComponent | OpraURLPathComponentInit)[]);
+    constructor(init?: string | OpraURLPath | URL | OpraURLPathComponent | OpraURLPathComponentInit);
+    get size(): number;
+    add(component: OpraURLPathComponent | {
+        resource: string;
+        key?: any;
+        typeCast?: string;
+    }): void;
+    add(name: string, key?: any, typeCast?: string): void;
+    clear(): void;
+    get(index: number): OpraURLPathComponent;
+    join(pathString: string): this;
+    entries(): IterableIterator<[OpraURLPathComponent, number]>;
+    values(): IterableIterator<OpraURLPathComponent>;
+    forEach(callback: (name: string, key: any, _this: this) => void): void;
+    getResource(index: number): string | undefined;
+    getKey(index: number): any;
+    toString(): string;
+    [Symbol.iterator](): IterableIterator<[OpraURLPathComponent, number]>;
+    [nodeInspectCustom](): OpraURLPathComponent[];
+    protected _add(component: any, key?: any, typeCast?: string): void;
+    protected _parse(v: string): void;
+}
+export {};