@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/type-alias-tag-value-node.js

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

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsesTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class UsesTagValueNode 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 'UsesTagValueNode';
+    }
+}
+exports.UsesTagValueNode = UsesTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/var-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 VarTagValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    variableName: string;
+    description: string;
+    constructor(type: TypeNode, variableName: string, description: string);
+    toString(): string;
+    getNodeType(): string;
+}

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

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

package/dist/phpdoc-parser/ast/type/array-shape-item-node.d.ts

@@ -0,0 +1,12 @@
+import { IdentifierTypeNode } from './identifier-type-node';
+import { TypeNode } from './type-node';
+import { ConstExprIntegerNode } from '../const-expr/const-expr-integer-node';
+import { ConstExprStringNode } from '../const-expr/const-expr-string-node';
+export declare class ArrayShapeItemNode extends TypeNode {
+    keyName: ConstExprIntegerNode | ConstExprStringNode | IdentifierTypeNode | null;
+    optional: boolean;
+    valueType: TypeNode;
+    constructor(keyName: ConstExprIntegerNode | ConstExprStringNode | IdentifierTypeNode | null, optional: boolean, valueType: TypeNode);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/array-shape-item-node.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayShapeItemNode = void 0;
+const type_node_1 = require("./type-node");
+class ArrayShapeItemNode extends type_node_1.TypeNode {
+    constructor(keyName, optional, valueType) {
+        super();
+        this.keyName = keyName;
+        this.optional = optional;
+        this.valueType = valueType;
+    }
+    toString() {
+        if (this.keyName !== null) {
+            return `${String(this.keyName)}${this.optional ? '?' : ''}: ${String(this.valueType)}`;
+        }
+        return String(this.valueType);
+    }
+    getNodeType() {
+        return 'ArrayShapeItemNode';
+    }
+}
+exports.ArrayShapeItemNode = ArrayShapeItemNode;

package/dist/phpdoc-parser/ast/type/array-shape-node.d.ts

@@ -0,0 +1,14 @@
+import { ArrayShapeItemNode } from './array-shape-item-node';
+import { TypeNode } from './type-node';
+export declare enum ArrayShapeNodeKind {
+    ARRAY = "array",
+    LIST = "list"
+}
+export declare class ArrayShapeNode extends TypeNode {
+    items: (ArrayShapeItemNode | string)[];
+    sealed: boolean;
+    kind: ArrayShapeNodeKind;
+    constructor(items: (ArrayShapeItemNode | string)[], sealed?: boolean, kind?: ArrayShapeNodeKind);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/array-shape-node.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayShapeNode = exports.ArrayShapeNodeKind = void 0;
+const type_node_1 = require("./type-node");
+var ArrayShapeNodeKind;
+(function (ArrayShapeNodeKind) {
+    ArrayShapeNodeKind["ARRAY"] = "array";
+    ArrayShapeNodeKind["LIST"] = "list";
+})(ArrayShapeNodeKind || (exports.ArrayShapeNodeKind = ArrayShapeNodeKind = {}));
+class ArrayShapeNode extends type_node_1.TypeNode {
+    constructor(items, sealed = true, kind = ArrayShapeNodeKind.ARRAY) {
+        super();
+        this.items = items;
+        this.sealed = sealed;
+        this.kind = kind;
+        this.items = items;
+        this.sealed = sealed;
+        this.kind = kind;
+    }
+    toString() {
+        const { items } = this;
+        if (!this.sealed) {
+            items.push('...');
+        }
+        return `${this.kind}{${items.join(', ')}}`;
+    }
+    getNodeType() {
+        return 'ArrayShapeNode';
+    }
+}
+exports.ArrayShapeNode = ArrayShapeNode;

package/dist/phpdoc-parser/ast/type/array-type-node.d.ts

@@ -0,0 +1,7 @@
+import { TypeNode } from './type-node';
+export declare class ArrayTypeNode extends TypeNode {
+    type: TypeNode;
+    constructor(type: TypeNode);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/array-type-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayTypeNode = void 0;
+const callable_type_node_1 = require("./callable-type-node");
+const const_type_node_1 = require("./const-type-node");
+const nullable_type_node_1 = require("./nullable-type-node");
+const type_node_1 = require("./type-node");
+class ArrayTypeNode extends type_node_1.TypeNode {
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    toString() {
+        if (this.type instanceof callable_type_node_1.CallableTypeNode ||
+            this.type instanceof const_type_node_1.ConstTypeNode ||
+            this.type instanceof nullable_type_node_1.NullableTypeNode) {
+            return `(${this.type.toString()})[]`;
+        }
+        return `${this.type.toString()}[]`;
+    }
+    getNodeType() {
+        return 'ArrayTypeNode';
+    }
+}
+exports.ArrayTypeNode = ArrayTypeNode;

package/dist/phpdoc-parser/ast/type/callable-type-node.d.ts

@@ -0,0 +1,11 @@
+import { CallableTypeParameterNode } from './callable-type-parameter-node';
+import { IdentifierTypeNode } from './identifier-type-node';
+import { TypeNode } from './type-node';
+export declare class CallableTypeNode extends TypeNode {
+    identifier: IdentifierTypeNode;
+    parameters: CallableTypeParameterNode[];
+    returnType: TypeNode;
+    constructor(identifier: IdentifierTypeNode, parameters: CallableTypeParameterNode[], returnType: TypeNode);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/callable-type-node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallableTypeNode = void 0;
+const type_node_1 = require("./type-node");
+class CallableTypeNode extends type_node_1.TypeNode {
+    constructor(identifier, parameters, returnType) {
+        super();
+        this.identifier = identifier;
+        this.parameters = parameters;
+        this.returnType = returnType;
+    }
+    toString() {
+        let { returnType } = this;
+        if (returnType instanceof CallableTypeNode) {
+            returnType = `(${returnType.toString()})`;
+        }
+        const parameters = this.parameters.join(', ');
+        return `${this.identifier.toString()}(${parameters}): ${returnType.toString()}`;
+    }
+    getNodeType() {
+        return 'CallableTypeNode';
+    }
+}
+exports.CallableTypeNode = CallableTypeNode;

package/dist/phpdoc-parser/ast/type/callable-type-parameter-node.d.ts

@@ -0,0 +1,11 @@
+import { TypeNode } from './type-node';
+export declare class CallableTypeParameterNode extends TypeNode {
+    type: TypeNode;
+    isReference: boolean;
+    isVariadic: boolean;
+    parameterName: string;
+    isOptional: boolean;
+    constructor(type: TypeNode, isReference: boolean, isVariadic: boolean, parameterName: string, isOptional: boolean);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/callable-type-parameter-node.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallableTypeParameterNode = void 0;
+const type_node_1 = require("./type-node");
+class CallableTypeParameterNode extends type_node_1.TypeNode {
+    constructor(type, isReference, isVariadic, parameterName, isOptional) {
+        super();
+        this.type = type;
+        this.isReference = isReference;
+        this.isVariadic = isVariadic;
+        this.parameterName = parameterName;
+        this.isOptional = isOptional;
+    }
+    toString() {
+        const type = `${this.type.toString()} `;
+        const isReference = this.isReference ? '&' : '';
+        const isVariadic = this.isVariadic ? '...' : '';
+        const isOptional = this.isOptional ? '=' : '';
+        return (`${type}${isReference}${isVariadic}${this.parameterName}`.trim() +
+            isOptional);
+    }
+    getNodeType() {
+        return 'CallableTypeParameterNode';
+    }
+}
+exports.CallableTypeParameterNode = CallableTypeParameterNode;

package/dist/phpdoc-parser/ast/type/conditional-type-for-parameter-node.d.ts

@@ -0,0 +1,11 @@
+import { TypeNode } from './type-node';
+export declare class ConditionalTypeForParameterNode extends TypeNode {
+    parameterName: string;
+    targetType: TypeNode;
+    ifCondition: TypeNode;
+    elseCondition: TypeNode;
+    negated: boolean;
+    constructor(parameterName: string, targetType: TypeNode, ifCondition: TypeNode, elseCondition: TypeNode, negated: boolean);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/conditional-type-for-parameter-node.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalTypeForParameterNode = void 0;
+const type_node_1 = require("./type-node");
+class ConditionalTypeForParameterNode extends type_node_1.TypeNode {
+    constructor(parameterName, targetType, ifCondition, elseCondition, negated) {
+        super();
+        this.parameterName = parameterName;
+        this.targetType = targetType;
+        this.ifCondition = ifCondition;
+        this.elseCondition = elseCondition;
+        this.negated = negated;
+    }
+    toString() {
+        return `(${this.parameterName} ${this.negated ? 'is not' : 'is'} ${this.targetType.toString()} ? ${this.ifCondition.toString()} : ${this.elseCondition.toString()})`;
+    }
+    getNodeType() {
+        return 'ConditionalTypeForParameterNode';
+    }
+}
+exports.ConditionalTypeForParameterNode = ConditionalTypeForParameterNode;

package/dist/phpdoc-parser/ast/type/conditional-type-node.d.ts

@@ -0,0 +1,11 @@
+import { TypeNode } from './type-node';
+export declare class ConditionalTypeNode extends TypeNode {
+    subjectType: TypeNode;
+    targetType: TypeNode;
+    ifType: TypeNode;
+    elseType: TypeNode;
+    negated: boolean;
+    constructor(subjectType: TypeNode, targetType: TypeNode, ifType: TypeNode, elseType: TypeNode, negated: boolean);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/conditional-type-node.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalTypeNode = void 0;
+const type_node_1 = require("./type-node");
+class ConditionalTypeNode extends type_node_1.TypeNode {
+    constructor(subjectType, targetType, ifType, elseType, negated) {
+        super();
+        this.subjectType = subjectType;
+        this.targetType = targetType;
+        this.ifType = ifType;
+        this.elseType = elseType;
+        this.negated = negated;
+    }
+    toString() {
+        return `(${this.subjectType.toString()} ${this.negated ? 'is not' : 'is'} ${this.targetType.toString()} ? ${this.ifType.toString()} : ${this.elseType.toString()})`;
+    }
+    getNodeType() {
+        return 'ConditionalTypeNode';
+    }
+}
+exports.ConditionalTypeNode = ConditionalTypeNode;

package/dist/phpdoc-parser/ast/type/const-type-node.d.ts

@@ -0,0 +1,8 @@
+import { TypeNode } from './type-node';
+import { ConstExprNode } from '../const-expr/const-expr-node';
+export declare class ConstTypeNode extends TypeNode {
+    constExpr: ConstExprNode;
+    constructor(constExpr: ConstExprNode);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/const-type-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstTypeNode = void 0;
+const type_node_1 = require("./type-node");
+class ConstTypeNode extends type_node_1.TypeNode {
+    constructor(constExpr) {
+        super();
+        this.constExpr = constExpr;
+    }
+    toString() {
+        return this.constExpr.toString();
+    }
+    getNodeType() {
+        return 'ConstTypeNode';
+    }
+}
+exports.ConstTypeNode = ConstTypeNode;

package/dist/phpdoc-parser/ast/type/generic-type-node.d.ts

@@ -0,0 +1,15 @@
+import { IdentifierTypeNode } from './identifier-type-node';
+import { TypeNode } from './type-node';
+export type GenericTypeNodeVariance = 'invariant' | 'covariant' | 'contravariant' | 'bivariant';
+export declare class GenericTypeNode extends TypeNode {
+    type: IdentifierTypeNode;
+    genericTypes: TypeNode[];
+    variances: string[];
+    static readonly VARIANCE_INVARIANT: "invariant";
+    static readonly VARIANCE_COVARIANT: "covariant";
+    static readonly VARIANCE_CONTRAVARIANT: "contravariant";
+    static readonly VARIANCE_BIVARIANT: "bivariant";
+    constructor(type: IdentifierTypeNode, genericTypes: TypeNode[], variances?: string[]);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/generic-type-node.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericTypeNode = void 0;
+const type_node_1 = require("./type-node");
+class GenericTypeNode extends type_node_1.TypeNode {
+    constructor(type, genericTypes, variances = []) {
+        super();
+        this.type = type;
+        this.genericTypes = genericTypes;
+        this.variances = variances;
+    }
+    toString() {
+        const genericTypes = [];
+        for (const index in this.genericTypes) {
+            const type = this.genericTypes[index];
+            const variance = this.variances[index] || GenericTypeNode.VARIANCE_INVARIANT;
+            if (variance === GenericTypeNode.VARIANCE_INVARIANT) {
+                genericTypes.push(type.toString());
+            }
+            else if (variance === GenericTypeNode.VARIANCE_BIVARIANT) {
+                genericTypes.push('*');
+            }
+            else {
+                genericTypes.push(`${variance} ${type.toString()}`);
+            }
+        }
+        return `${this.type.toString()}<${genericTypes.join(', ')}>`;
+    }
+    getNodeType() {
+        return 'GenericTypeNode';
+    }
+}
+exports.GenericTypeNode = GenericTypeNode;
+GenericTypeNode.VARIANCE_INVARIANT = 'invariant';
+GenericTypeNode.VARIANCE_COVARIANT = 'covariant';
+GenericTypeNode.VARIANCE_CONTRAVARIANT = 'contravariant';
+GenericTypeNode.VARIANCE_BIVARIANT = 'bivariant';

package/dist/phpdoc-parser/ast/type/identifier-type-node.d.ts

@@ -0,0 +1,7 @@
+import { TypeNode } from './type-node';
+export declare class IdentifierTypeNode extends TypeNode {
+    name: string;
+    constructor(name: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/identifier-type-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifierTypeNode = void 0;
+const type_node_1 = require("./type-node");
+class IdentifierTypeNode extends type_node_1.TypeNode {
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+    toString() {
+        return this.name;
+    }
+    getNodeType() {
+        return 'IdentifierTypeNode';
+    }
+}
+exports.IdentifierTypeNode = IdentifierTypeNode;

package/dist/phpdoc-parser/ast/type/intersection-type-node.d.ts

@@ -0,0 +1,7 @@
+import { TypeNode } from './type-node';
+export declare class IntersectionTypeNode extends TypeNode {
+    types: TypeNode[];
+    constructor(types: TypeNode[]);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/intersection-type-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntersectionTypeNode = void 0;
+const nullable_type_node_1 = require("./nullable-type-node");
+const type_node_1 = require("./type-node");
+class IntersectionTypeNode extends type_node_1.TypeNode {
+    constructor(types) {
+        super();
+        this.types = types;
+    }
+    toString() {
+        return `(${this.types
+            .map((type) => {
+            if (type instanceof nullable_type_node_1.NullableTypeNode) {
+                return `(${type.toString()})`;
+            }
+            return type.toString();
+        })
+            .join(' & ')})`;
+    }
+    getNodeType() {
+        return 'IntersectionTypeNode';
+    }
+}
+exports.IntersectionTypeNode = IntersectionTypeNode;

package/dist/phpdoc-parser/ast/type/invalid-type-node.d.ts

@@ -0,0 +1,10 @@
+import { TypeNode } from './type-node';
+import { ParserException } from '../../parser/parser-exception';
+export declare class InvalidTypeNode extends TypeNode {
+    exception: ParserException;
+    exceptionArgs: ConstructorParameters<typeof ParserException>;
+    constructor(exception: ParserException);
+    getException(): ParserException;
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/invalid-type-node.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidTypeNode = void 0;
+const type_node_1 = require("./type-node");
+const parser_exception_1 = require("../../parser/parser-exception");
+class InvalidTypeNode extends type_node_1.TypeNode {
+    constructor(exception) {
+        super();
+        this.exception = exception;
+        this.exceptionArgs = [
+            exception.getCurrentTokenValue(),
+            exception.getCurrentTokenType(),
+            exception.getCurrentOffset(),
+            exception.getExpectedTokenType(),
+            exception.getExpectedTokenValue(),
+            exception.getCurrentTokenLine(),
+        ];
+    }
+    getException() {
+        return new parser_exception_1.ParserException(...this.exceptionArgs);
+    }
+    toString() {
+        return '*Invalid type*';
+    }
+    getNodeType() {
+        return 'InvalidTypeNode';
+    }
+}
+exports.InvalidTypeNode = InvalidTypeNode;

package/dist/phpdoc-parser/ast/type/nullable-type-node.d.ts

@@ -0,0 +1,7 @@
+import { TypeNode } from './type-node';
+export declare class NullableTypeNode extends TypeNode {
+    type: TypeNode;
+    constructor(type: TypeNode);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/nullable-type-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullableTypeNode = void 0;
+const type_node_1 = require("./type-node");
+class NullableTypeNode extends type_node_1.TypeNode {
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    toString() {
+        return `?${this.type.toString()}`;
+    }
+    getNodeType() {
+        return 'NullableTypeNode';
+    }
+}
+exports.NullableTypeNode = NullableTypeNode;

package/dist/phpdoc-parser/ast/type/object-shape-item-node.d.ts

@@ -0,0 +1,11 @@
+import { IdentifierTypeNode } from './identifier-type-node';
+import { TypeNode } from './type-node';
+import { ConstExprStringNode } from '../const-expr/const-expr-string-node';
+export declare class ObjectShapeItemNode extends TypeNode {
+    keyName: ConstExprStringNode | IdentifierTypeNode;
+    optional: boolean;
+    valueType: TypeNode;
+    constructor(keyName: ConstExprStringNode | IdentifierTypeNode, optional: boolean, valueType: TypeNode);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/object-shape-item-node.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectShapeItemNode = void 0;
+const type_node_1 = require("./type-node");
+class ObjectShapeItemNode extends type_node_1.TypeNode {
+    constructor(keyName, optional, valueType) {
+        super();
+        this.keyName = keyName;
+        this.optional = optional;
+        this.valueType = valueType;
+    }
+    toString() {
+        if (this.keyName !== null) {
+            return `${this.keyName.toString()}${this.optional ? '?' : ''}: ${this.valueType.toString()}`;
+        }
+        return this.valueType.toString();
+    }
+    getNodeType() {
+        return 'ObjectShapeItemNode';
+    }
+}
+exports.ObjectShapeItemNode = ObjectShapeItemNode;

package/dist/phpdoc-parser/ast/type/object-shape-node.d.ts

@@ -0,0 +1,8 @@
+import { ObjectShapeItemNode } from './object-shape-item-node';
+import { TypeNode } from './type-node';
+export declare class ObjectShapeNode extends TypeNode {
+    items: ObjectShapeItemNode[];
+    constructor(items: ObjectShapeItemNode[]);
+    toString(): string;
+    getNodeType(): string;
+}