@rightcapital/phpdoc-parser 0.3.3-feature-add-basic-ci.7.0 → 0.3.3-feature-add-basic-ci.8.0

package/dist/phpdoc-parser/ast/php-doc/mixin-tag-value-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MixinTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class MixinTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, description) {
+        super();
+        this.type = type;
+        this.description = description;
+    }
+    toString() {
+        return `${this.type.toString()} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'MixinTagValueNode';
+    }
+}
+exports.MixinTagValueNode = MixinTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/param-out-tag-value-node.d.ts

@@ -0,0 +1,10 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class ParamOutTagValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    parameterName: string;
+    description: string;
+    constructor(type: TypeNode, parameterName: string, description: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/param-out-tag-value-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamOutTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class ParamOutTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, parameterName, description) {
+        super();
+        this.type = type;
+        this.parameterName = parameterName;
+        this.description = description;
+    }
+    toString() {
+        return `${this.type.toString()} ${this.parameterName} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'ParamOutTagValueNode';
+    }
+}
+exports.ParamOutTagValueNode = ParamOutTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/param-tag-value-node.d.ts

@@ -0,0 +1,12 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class ParamTagValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    isVariadic: boolean;
+    parameterName: string;
+    description: string;
+    isReference: boolean;
+    constructor(type: TypeNode, isVariadic: boolean, parameterName: string, description: string, isReference?: boolean);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/param-tag-value-node.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class ParamTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, isVariadic, parameterName, description, isReference = false) {
+        super();
+        this.type = type;
+        this.isVariadic = isVariadic;
+        this.parameterName = parameterName;
+        this.description = description;
+        this.isReference = isReference;
+        this.type = type;
+        this.isReference = isReference;
+        this.isVariadic = isVariadic;
+        this.parameterName = parameterName;
+        this.description = description;
+    }
+    toString() {
+        const reference = this.isReference ? '&' : '';
+        const variadic = this.isVariadic ? '...' : '';
+        return `${this.type.toString()} ${reference}${variadic}${this.parameterName} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'ParamTagValueNode';
+    }
+}
+exports.ParamTagValueNode = ParamTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/php-doc-child-node.d.ts

@@ -0,0 +1,4 @@
+import { BaseNode } from '../base-node';
+export declare class PhpDocChildNode extends BaseNode {
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/php-doc-child-node.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhpDocChildNode = void 0;
+const base_node_1 = require("../base-node");
+class PhpDocChildNode extends base_node_1.BaseNode {
+    getNodeType() {
+        return 'PhpDocChildNode';
+    }
+}
+exports.PhpDocChildNode = PhpDocChildNode;

package/dist/phpdoc-parser/ast/php-doc/php-doc-node.d.ts

@@ -0,0 +1,32 @@
+import { DeprecatedTagValueNode } from './deprecated-tag-value-node';
+import { ExtendsTagValueNode } from './extends-tag-value-node';
+import { ImplementsTagValueNode } from './implements-tag-value-node';
+import { MixinTagValueNode } from './mixin-tag-value-node';
+import { ParamTagValueNode } from './param-tag-value-node';
+import { PhpDocChildNode } from './php-doc-child-node';
+import { PhpDocTagNode } from './php-doc-tag-node';
+import { ReturnTagValueNode } from './return-tag-value-node';
+import { TemplateTagValueNode } from './template-tag-value-node';
+import { ThrowsTagValueNode } from './throws-tag-value-node';
+import { TypelessParamTagValueNode } from './typeless-param-tag-value-node';
+import { UsesTagValueNode } from './uses-tag-value-node';
+import { VarTagValueNode } from './var-tag-value-node';
+import { BaseNode } from '../base-node';
+export declare class PhpDocNode extends BaseNode {
+    children: PhpDocChildNode[];
+    constructor(children: PhpDocChildNode[]);
+    getTags(): PhpDocTagNode[];
+    getTagsByName(tagName: string): PhpDocTagNode[];
+    getVarTagValues(tagName?: string): VarTagValueNode[];
+    getParamTagValues(tagName?: string): ParamTagValueNode[];
+    getTypelessParamTagValues(tagName?: string): TypelessParamTagValueNode[];
+    getTemplateTagValues(tagName?: string): TemplateTagValueNode[];
+    getExtendsTagValues(tagName?: string): ExtendsTagValueNode[];
+    getImplementsTagValues(tagName?: string): ImplementsTagValueNode[];
+    getUsesTagValues(tagName?: string): UsesTagValueNode[];
+    getReturnTagValues(tagName?: string): ReturnTagValueNode[];
+    getThrowsTagValues(tagName?: string): ThrowsTagValueNode[];
+    getMixinTagValues(tagName?: string): MixinTagValueNode[];
+    getDeprecatedTagValues(): DeprecatedTagValueNode[];
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/php-doc-node.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhpDocNode = void 0;
+const deprecated_tag_value_node_1 = require("./deprecated-tag-value-node");
+const extends_tag_value_node_1 = require("./extends-tag-value-node");
+const implements_tag_value_node_1 = require("./implements-tag-value-node");
+const mixin_tag_value_node_1 = require("./mixin-tag-value-node");
+const param_tag_value_node_1 = require("./param-tag-value-node");
+const php_doc_tag_node_1 = require("./php-doc-tag-node");
+const return_tag_value_node_1 = require("./return-tag-value-node");
+const template_tag_value_node_1 = require("./template-tag-value-node");
+const throws_tag_value_node_1 = require("./throws-tag-value-node");
+const typeless_param_tag_value_node_1 = require("./typeless-param-tag-value-node");
+const uses_tag_value_node_1 = require("./uses-tag-value-node");
+const var_tag_value_node_1 = require("./var-tag-value-node");
+const base_node_1 = require("../base-node");
+class PhpDocNode extends base_node_1.BaseNode {
+    constructor(children) {
+        super();
+        this.children = children;
+    }
+    getTags() {
+        return this.children.filter((child) => {
+            return child instanceof php_doc_tag_node_1.PhpDocTagNode;
+        });
+    }
+    getTagsByName(tagName) {
+        return this.getTags().filter((tag) => {
+            return tag.name === tagName;
+        });
+    }
+    getVarTagValues(tagName = '@var') {
+        return this.getTagsByName(tagName)
+            .map((tag) => tag.value)
+            .filter((value) => {
+            return value instanceof var_tag_value_node_1.VarTagValueNode;
+        });
+    }
+    getParamTagValues(tagName = '@param') {
+        return this.getTagsByName(tagName)
+            .map((tag) => tag.value)
+            .filter((value) => {
+            return value instanceof param_tag_value_node_1.ParamTagValueNode;
+        });
+    }
+    getTypelessParamTagValues(tagName = '@param') {
+        return this.getTagsByName(tagName)
+            .map((tag) => tag.value)
+            .filter((value) => {
+            return value instanceof typeless_param_tag_value_node_1.TypelessParamTagValueNode;
+        });
+    }
+    getTemplateTagValues(tagName = '@template') {
+        return this.getTagsByName(tagName)
+            .map((tag) => tag.value)
+            .filter((value) => value instanceof template_tag_value_node_1.TemplateTagValueNode);
+    }
+    getExtendsTagValues(tagName = '@extends') {
+        return this.getTagsByName(tagName)
+            .map((tag) => tag.value)
+            .filter((value) => value instanceof extends_tag_value_node_1.ExtendsTagValueNode);
+    }
+    getImplementsTagValues(tagName = '@implements') {
+        return this.getTagsByName(tagName)
+            .map((tag) => tag.value)
+            .filter((value) => value instanceof implements_tag_value_node_1.ImplementsTagValueNode);
+    }
+    getUsesTagValues(tagName = '@use') {
+        return this.getTagsByName(tagName)
+            .map((tag) => tag.value)
+            .filter((value) => value instanceof uses_tag_value_node_1.UsesTagValueNode);
+    }
+    getReturnTagValues(tagName = '@return') {
+        return this.getTagsByName(tagName)
+            .map((tag) => tag.value)
+            .filter((value) => value instanceof return_tag_value_node_1.ReturnTagValueNode);
+    }
+    getThrowsTagValues(tagName = '@throws') {
+        return this.getTagsByName(tagName)
+            .map((tag) => tag.value)
+            .filter((value) => value instanceof throws_tag_value_node_1.ThrowsTagValueNode);
+    }
+    getMixinTagValues(tagName = '@mixin') {
+        return this.getTagsByName(tagName)
+            .map((tag) => tag.value)
+            .filter((value) => value instanceof mixin_tag_value_node_1.MixinTagValueNode);
+    }
+    getDeprecatedTagValues() {
+        return this.getTagsByName('@deprecated')
+            .map((tag) => tag.value)
+            .filter((value) => value instanceof deprecated_tag_value_node_1.DeprecatedTagValueNode);
+    }
+    getNodeType() {
+        return 'PhpDocNode';
+    }
+}
+exports.PhpDocNode = PhpDocNode;

package/dist/phpdoc-parser/ast/php-doc/php-doc-tag-node.d.ts

@@ -0,0 +1,56 @@
+import type { AssertTagMethodValueNode } from './assert-tag-method-value-node';
+import type { AssertTagPropertyValueNode } from './assert-tag-property-value-node';
+import type { AssertTagValueNode } from './assert-tag-value-node';
+import type { DeprecatedTagValueNode } from './deprecated-tag-value-node';
+import type { ExtendsTagValueNode } from './extends-tag-value-node';
+import type { GenericTagValueNode } from './generic-tag-value-node';
+import type { ImplementsTagValueNode } from './implements-tag-value-node';
+import type { InvalidTagValueNode } from './invalid-tag-value-node';
+import type { MethodTagValueNode } from './method-tag-value-node';
+import type { MethodTagValueParameterNode } from './method-tag-value-parameter-node';
+import type { MixinTagValueNode } from './mixin-tag-value-node';
+import type { ParamOutTagValueNode } from './param-out-tag-value-node';
+import type { ParamTagValueNode } from './param-tag-value-node';
+import { PhpDocChildNode } from './php-doc-child-node';
+import type { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import type { PropertyTagValueNode } from './property-tag-value-node';
+import type { ReturnTagValueNode } from './return-tag-value-node';
+import type { SelfOutTagValueNode } from './self-out-tag-value-node';
+import type { TemplateTagValueNode } from './template-tag-value-node';
+import type { ThrowsTagValueNode } from './throws-tag-value-node';
+import type { TypeAliasImportTagValueNode } from './type-alias-import-tag-value-node';
+import type { TypeAliasTagValueNode } from './type-alias-tag-value-node';
+import type { TypelessParamTagValueNode } from './typeless-param-tag-value-node';
+import type { UsesTagValueNode } from './uses-tag-value-node';
+import type { VarTagValueNode } from './var-tag-value-node';
+export declare class PhpDocTagNode extends PhpDocChildNode {
+    name: string;
+    value: PhpDocTagValueNode;
+    constructor(name: string, value: PhpDocTagValueNode);
+    toString(): string;
+    getNodeType(): string;
+    isParamOutTagValueNode(): this is ParamOutTagValueNode;
+    isAssertTagValueNode(): this is AssertTagValueNode;
+    isUsesTagValueNode(): this is UsesTagValueNode;
+    isInvalidTagValueNode(): this is InvalidTagValueNode;
+    isMethodTagValueNode(): this is MethodTagValueNode;
+    isDeprecatedTagValueNode(): this is DeprecatedTagValueNode;
+    isExtendsTagValueNode(): this is ExtendsTagValueNode;
+    isParamTagValueNode(): this is ParamTagValueNode;
+    isGenericTagValueNode(): this is GenericTagValueNode;
+    isTypeAliasTagValueNode(): this is TypeAliasTagValueNode;
+    isAssertTagPropertyValueNode(): this is AssertTagPropertyValueNode;
+    isTypelessParamTagValueNode(): this is TypelessParamTagValueNode;
+    isVarTagValueNode(): this is VarTagValueNode;
+    isMethodTagValueParameterNode(): this is MethodTagValueParameterNode;
+    isAssertTagMethodValueNode(): this is AssertTagMethodValueNode;
+    isTemplateTagValueNode(): this is TemplateTagValueNode;
+    isImplementsTagValueNode(): this is ImplementsTagValueNode;
+    isThrowsTagValueNode(): this is ThrowsTagValueNode;
+    isSelfOutTagValueNode(): this is SelfOutTagValueNode;
+    isPropertyTagValueNode(): this is PropertyTagValueNode;
+    isTypeAliasImportTagValueNode(): this is TypeAliasImportTagValueNode;
+    isMixinTagValueNode(): this is MixinTagValueNode;
+    isPhpDocTagValueNode(): this is PhpDocTagValueNode;
+    isReturnTagValueNode(): this is ReturnTagValueNode;
+}

package/dist/phpdoc-parser/ast/php-doc/php-doc-tag-node.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhpDocTagNode = void 0;
+const php_doc_child_node_1 = require("./php-doc-child-node");
+class PhpDocTagNode extends php_doc_child_node_1.PhpDocChildNode {
+    constructor(name, value) {
+        super();
+        this.name = name;
+        this.value = value;
+    }
+    toString() {
+        return `${this.name} ${this.value.toString()}`.trim();
+    }
+    getNodeType() {
+        return 'PhpDocTagNode';
+    }
+    isParamOutTagValueNode() {
+        return this.getNodeType() === 'ParamOutTagValueNode';
+    }
+    isAssertTagValueNode() {
+        return this.getNodeType() === 'AssertTagValueNode';
+    }
+    isUsesTagValueNode() {
+        return this.getNodeType() === 'UsesTagValueNode';
+    }
+    isInvalidTagValueNode() {
+        return this.getNodeType() === 'InvalidTagValueNode';
+    }
+    isMethodTagValueNode() {
+        return this.getNodeType() === 'MethodTagValueNode';
+    }
+    isDeprecatedTagValueNode() {
+        return this.getNodeType() === 'DeprecatedTagValueNode';
+    }
+    isExtendsTagValueNode() {
+        return this.getNodeType() === 'ExtendsTagValueNode';
+    }
+    isParamTagValueNode() {
+        return this.getNodeType() === 'ParamTagValueNode';
+    }
+    isGenericTagValueNode() {
+        return this.getNodeType() === 'GenericTagValueNode';
+    }
+    isTypeAliasTagValueNode() {
+        return this.getNodeType() === 'TypeAliasTagValueNode';
+    }
+    isAssertTagPropertyValueNode() {
+        return this.getNodeType() === 'AssertTagPropertyValueNode';
+    }
+    isTypelessParamTagValueNode() {
+        return this.getNodeType() === 'TypelessParamTagValueNode';
+    }
+    isVarTagValueNode() {
+        return this.getNodeType() === 'VarTagValueNode';
+    }
+    isMethodTagValueParameterNode() {
+        return this.getNodeType() === 'MethodTagValueParameterNode';
+    }
+    isAssertTagMethodValueNode() {
+        return this.getNodeType() === 'AssertTagMethodValueNode';
+    }
+    isTemplateTagValueNode() {
+        return this.getNodeType() === 'TemplateTagValueNode';
+    }
+    isImplementsTagValueNode() {
+        return this.getNodeType() === 'ImplementsTagValueNode';
+    }
+    isThrowsTagValueNode() {
+        return this.getNodeType() === 'ThrowsTagValueNode';
+    }
+    isSelfOutTagValueNode() {
+        return this.getNodeType() === 'SelfOutTagValueNode';
+    }
+    isPropertyTagValueNode() {
+        return this.getNodeType() === 'PropertyTagValueNode';
+    }
+    isTypeAliasImportTagValueNode() {
+        return this.getNodeType() === 'TypeAliasImportTagValueNode';
+    }
+    isMixinTagValueNode() {
+        return this.getNodeType() === 'MixinTagValueNode';
+    }
+    isPhpDocTagValueNode() {
+        return this.getNodeType() === 'PhpDocTagValueNode';
+    }
+    isReturnTagValueNode() {
+        return this.getNodeType() === 'ReturnTagValueNode';
+    }
+}
+exports.PhpDocTagNode = PhpDocTagNode;

package/dist/phpdoc-parser/ast/php-doc/php-doc-tag-value-node.d.ts

@@ -0,0 +1,4 @@
+import { BaseNode } from '../base-node';
+export declare class PhpDocTagValueNode extends BaseNode {
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/php-doc-tag-value-node.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhpDocTagValueNode = void 0;
+const base_node_1 = require("../base-node");
+class PhpDocTagValueNode extends base_node_1.BaseNode {
+    getNodeType() {
+        return 'PhpDocTagValueNode';
+    }
+}
+exports.PhpDocTagValueNode = PhpDocTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/php-doc-text-node.d.ts

@@ -0,0 +1,7 @@
+import { PhpDocChildNode } from './php-doc-child-node';
+export declare class PhpDocTextNode extends PhpDocChildNode {
+    text: string;
+    constructor(text: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/php-doc-text-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhpDocTextNode = void 0;
+const php_doc_child_node_1 = require("./php-doc-child-node");
+class PhpDocTextNode extends php_doc_child_node_1.PhpDocChildNode {
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+    toString() {
+        return this.text;
+    }
+    getNodeType() {
+        return 'PhpDocTextNode';
+    }
+}
+exports.PhpDocTextNode = PhpDocTextNode;

package/dist/phpdoc-parser/ast/php-doc/property-tag-value-node.d.ts

@@ -0,0 +1,10 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class PropertyTagValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    propertyName: string;
+    description: string;
+    constructor(type: TypeNode, propertyName: string, description: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/property-tag-value-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class PropertyTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, propertyName, description) {
+        super();
+        this.type = type;
+        this.propertyName = propertyName;
+        this.description = description;
+    }
+    toString() {
+        return `${this.type.toString()} ${this.propertyName} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'PropertyTagValueNode';
+    }
+}
+exports.PropertyTagValueNode = PropertyTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/return-tag-value-node.d.ts

@@ -0,0 +1,9 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class ReturnTagValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    description: string;
+    constructor(type: TypeNode, description: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/return-tag-value-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class ReturnTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, description) {
+        super();
+        this.type = type;
+        this.description = description;
+    }
+    toString() {
+        return `${this.type.toString()} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'ReturnTagValueNode';
+    }
+}
+exports.ReturnTagValueNode = ReturnTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/self-out-tag-value-node.d.ts

@@ -0,0 +1,9 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class SelfOutTagValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    description: string;
+    constructor(type: TypeNode, description: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/self-out-tag-value-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelfOutTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class SelfOutTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, description) {
+        super();
+        this.type = type;
+        this.description = description;
+    }
+    toString() {
+        return `${this.type.toString()} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'SelfOutTagValueNode';
+    }
+}
+exports.SelfOutTagValueNode = SelfOutTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/template-tag-value-node.d.ts

@@ -0,0 +1,11 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class TemplateTagValueNode extends PhpDocTagValueNode {
+    name: string;
+    bound: TypeNode | null;
+    description: string;
+    defaultTypeNode: TypeNode | null;
+    constructor(name: string, bound: TypeNode | null, description: string, defaultTypeNode?: TypeNode | null);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/template-tag-value-node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class TemplateTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(name, bound, description, defaultTypeNode = null) {
+        super();
+        this.name = name;
+        this.bound = bound;
+        this.description = description;
+        this.defaultTypeNode = defaultTypeNode;
+    }
+    toString() {
+        const bound = this.bound !== null ? ` of ${this.bound.toString()}` : '';
+        const defaultString = this.defaultTypeNode !== null
+            ? ` = ${this.defaultTypeNode.toString()}`
+            : '';
+        return `${this.name}${bound}${defaultString} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'TemplateTagValueNode';
+    }
+}
+exports.TemplateTagValueNode = TemplateTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/throws-tag-value-node.d.ts

@@ -0,0 +1,9 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class ThrowsTagValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    description: string;
+    constructor(type: TypeNode, description?: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/throws-tag-value-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThrowsTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class ThrowsTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, description = '') {
+        super();
+        this.type = type;
+        this.description = description;
+    }
+    toString() {
+        return `${this.type.toString()} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'ThrowsTagValueNode';
+    }
+}
+exports.ThrowsTagValueNode = ThrowsTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/type-alias-import-tag-value-node.d.ts

@@ -0,0 +1,10 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { IdentifierTypeNode } from '../type/identifier-type-node';
+export declare class TypeAliasImportTagValueNode extends PhpDocTagValueNode {
+    importedAlias: string;
+    importedFrom: IdentifierTypeNode;
+    importedAs?: string;
+    constructor(importedAlias: string, importedFrom: IdentifierTypeNode, importedAs?: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/type-alias-import-tag-value-node.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeAliasImportTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class TypeAliasImportTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(importedAlias, importedFrom, importedAs) {
+        super();
+        this.importedAlias = importedAlias;
+        this.importedFrom = importedFrom;
+        this.importedAs = importedAs;
+    }
+    toString() {
+        return `${this.importedAlias} from ${this.importedFrom.toString()}${(this
+            .importedAs
+            ? ` as ${this.importedAs}`
+            : '').trim()}`;
+    }
+    getNodeType() {
+        return 'TypeAliasImportTagValueNode';
+    }
+}
+exports.TypeAliasImportTagValueNode = TypeAliasImportTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/type-alias-tag-value-node.d.ts

@@ -0,0 +1,9 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class TypeAliasTagValueNode extends PhpDocTagValueNode {
+    alias: string;
+    type: TypeNode;
+    constructor(alias: string, type: TypeNode);
+    toString(): string;
+    getNodeType(): string;
+}