@microsoft/api-extractor-model 7.32.1 → 7.33.0

package/lib-esm/mixins/ApiProtectedMixin.js

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+const _isProtected = Symbol('ApiProtectedMixin._isProtected');
+/**
+ * Mixin function for {@link (ApiProtectedMixin:interface)}.
+ *
+ * @param baseClass - The base class to be extended
+ * @returns A child class that extends baseClass, adding the {@link (ApiProtectedMixin:interface)} functionality.
+ *
+ * @public
+ */
+export function ApiProtectedMixin(baseClass
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    class MixedClass extends baseClass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            const options = args[0];
+            this[_isProtected] = options.isProtected;
+        }
+        /** @override */
+        static onDeserializeInto(options, context, jsonObject) {
+            baseClass.onDeserializeInto(options, context, jsonObject);
+            options.isProtected = jsonObject.isProtected;
+        }
+        get isProtected() {
+            return this[_isProtected];
+        }
+        /** @override */
+        serializeInto(jsonObject) {
+            super.serializeInto(jsonObject);
+            jsonObject.isProtected = this.isProtected;
+        }
+    }
+    return MixedClass;
+}
+/**
+ * Static members for {@link (ApiProtectedMixin:interface)}.
+ * @public
+ */
+(function (ApiProtectedMixin) {
+    /**
+     * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiProtectedMixin` mixin.
+     *
+     * @remarks
+     *
+     * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of
+     * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however
+     * the TypeScript type system cannot invoke a runtime test.)
+     */
+    function isBaseClassOf(apiItem) {
+        return apiItem.hasOwnProperty(_isProtected);
+    }
+    ApiProtectedMixin.isBaseClassOf = isBaseClassOf;
+})(ApiProtectedMixin || (ApiProtectedMixin = {}));
+//# sourceMappingURL=ApiProtectedMixin.js.map

package/lib-esm/mixins/ApiProtectedMixin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiProtectedMixin.js","sourceRoot":"","sources":["../../src/mixins/ApiProtectedMixin.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAmB3D,MAAM,YAAY,GAAkB,MAAM,CAAC,gCAAgC,CAAC,CAAC;AA4B7E;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAC/B,SAAqB;AACrB,8DAA8D;;IAE9D,MAAM,UAAW,SAAQ,SAAS;QAGhC,8DAA8D;QAC9D,YAAmB,GAAG,IAAW;YAC/B,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;YAEf,MAAM,OAAO,GAA8B,IAAI,CAAC,CAAC,CAAC,CAAC;YACnD,IAAI,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;QAC3C,CAAC;QAED,gBAAgB;QACT,MAAM,CAAC,iBAAiB,CAC7B,OAA2C,EAC3C,OAA4B,EAC5B,UAAkC;YAElC,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;YAE1D,OAAO,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;QAC/C,CAAC;QAED,IAAW,WAAW;YACpB,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC;QAC5B,CAAC;QAED,gBAAgB;QACT,aAAa,CAAC,UAA2C;YAC9D,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YAEhC,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QAC5C,CAAC;KACF;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;GAGG;AACH,WAAiB,iBAAiB;IAChC;;;;;;;;OAQG;IACH,SAAgB,aAAa,CAAC,OAAgB;QAC5C,OAAO,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;IAC9C,CAAC;IAFe,+BAAa,gBAE5B,CAAA;AACH,CAAC,EAbgB,iBAAiB,KAAjB,iBAAiB,QAajC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nimport type { ApiItem, IApiItemJson, IApiItemConstructor, IApiItemOptions } from '../items/ApiItem';\nimport type { DeserializerContext } from '../model/DeserializerContext';\n\n/**\n * Constructor options for {@link (IApiProtectedMixinOptions:interface)}.\n * @public\n */\nexport interface IApiProtectedMixinOptions extends IApiItemOptions {\n  isProtected: boolean;\n}\n\nexport interface IApiProtectedMixinJson extends IApiItemJson {\n  isProtected: boolean;\n}\n\nconst _isProtected: unique symbol = Symbol('ApiProtectedMixin._isProtected');\n\n/**\n * The mixin base class for API items that can have the TypeScript `protected` keyword applied to them.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.  The non-abstract classes (e.g. `ApiClass`, `ApiEnum`, `ApiInterface`, etc.) use\n * TypeScript \"mixin\" functions (e.g. `ApiDeclaredItem`, `ApiItemContainerMixin`, etc.) to add various\n * features that cannot be represented as a normal inheritance chain (since TypeScript does not allow a child class\n * to extend more than one base class).  The \"mixin\" is a TypeScript merged declaration with three components:\n * the function that generates a subclass, an interface that describes the members of the subclass, and\n * a namespace containing static members of the class.\n *\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport interface ApiProtectedMixin extends ApiItem {\n  /**\n   * Whether the declaration has the TypeScript `protected` keyword.\n   */\n  readonly isProtected: boolean;\n\n  /** @override */\n  serializeInto(jsonObject: Partial<IApiItemJson>): void;\n}\n\n/**\n * Mixin function for {@link (ApiProtectedMixin:interface)}.\n *\n * @param baseClass - The base class to be extended\n * @returns A child class that extends baseClass, adding the {@link (ApiProtectedMixin:interface)} functionality.\n *\n * @public\n */\nexport function ApiProtectedMixin<TBaseClass extends IApiItemConstructor>(\n  baseClass: TBaseClass\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): TBaseClass & (new (...args: any[]) => ApiProtectedMixin) {\n  class MixedClass extends baseClass implements ApiProtectedMixin {\n    public [_isProtected]: boolean;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    public constructor(...args: any[]) {\n      super(...args);\n\n      const options: IApiProtectedMixinOptions = args[0];\n      this[_isProtected] = options.isProtected;\n    }\n\n    /** @override */\n    public static onDeserializeInto(\n      options: Partial<IApiProtectedMixinOptions>,\n      context: DeserializerContext,\n      jsonObject: IApiProtectedMixinJson\n    ): void {\n      baseClass.onDeserializeInto(options, context, jsonObject);\n\n      options.isProtected = jsonObject.isProtected;\n    }\n\n    public get isProtected(): boolean {\n      return this[_isProtected];\n    }\n\n    /** @override */\n    public serializeInto(jsonObject: Partial<IApiProtectedMixinJson>): void {\n      super.serializeInto(jsonObject);\n\n      jsonObject.isProtected = this.isProtected;\n    }\n  }\n\n  return MixedClass;\n}\n\n/**\n * Static members for {@link (ApiProtectedMixin:interface)}.\n * @public\n */\nexport namespace ApiProtectedMixin {\n  /**\n   * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiProtectedMixin` mixin.\n   *\n   * @remarks\n   *\n   * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of\n   * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however\n   * the TypeScript type system cannot invoke a runtime test.)\n   */\n  export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiProtectedMixin {\n    return apiItem.hasOwnProperty(_isProtected);\n  }\n}\n"]}

package/lib-esm/mixins/ApiReadonlyMixin.js

@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+const _isReadonly = Symbol('ApiReadonlyMixin._isReadonly');
+/**
+ * Mixin function for {@link (ApiReadonlyMixin:interface)}.
+ *
+ * @param baseClass - The base class to be extended
+ * @returns A child class that extends baseClass, adding the {@link (ApiReadonlyMixin:interface)}
+ * functionality.
+ *
+ * @public
+ */
+export function ApiReadonlyMixin(baseClass
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    class MixedClass extends baseClass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            const options = args[0];
+            this[_isReadonly] = options.isReadonly;
+        }
+        /** @override */
+        static onDeserializeInto(options, context, jsonObject) {
+            baseClass.onDeserializeInto(options, context, jsonObject);
+            options.isReadonly = jsonObject.isReadonly || false;
+        }
+        get isReadonly() {
+            return this[_isReadonly];
+        }
+        /** @override */
+        serializeInto(jsonObject) {
+            super.serializeInto(jsonObject);
+            jsonObject.isReadonly = this.isReadonly;
+        }
+    }
+    return MixedClass;
+}
+/**
+ * Static members for {@link (ApiReadonlyMixin:interface)}.
+ * @public
+ */
+(function (ApiReadonlyMixin) {
+    /**
+     * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiReadonlyMixin` mixin.
+     *
+     * @remarks
+     *
+     * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of
+     * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however
+     * the TypeScript type system cannot invoke a runtime test.)
+     */
+    function isBaseClassOf(apiItem) {
+        return apiItem.hasOwnProperty(_isReadonly);
+    }
+    ApiReadonlyMixin.isBaseClassOf = isBaseClassOf;
+})(ApiReadonlyMixin || (ApiReadonlyMixin = {}));
+//# sourceMappingURL=ApiReadonlyMixin.js.map

package/lib-esm/mixins/ApiReadonlyMixin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiReadonlyMixin.js","sourceRoot":"","sources":["../../src/mixins/ApiReadonlyMixin.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAmB3D,MAAM,WAAW,GAAkB,MAAM,CAAC,8BAA8B,CAAC,CAAC;AAiD1E;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAC9B,SAAqB;AACrB,8DAA8D;;IAE9D,MAAM,UAAW,SAAQ,SAAS;QAGhC,8DAA8D;QAC9D,YAAmB,GAAG,IAAW;YAC/B,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;YAEf,MAAM,OAAO,GAA6B,IAAI,CAAC,CAAC,CAAC,CAAC;YAClD,IAAI,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC;QACzC,CAAC;QAED,gBAAgB;QACT,MAAM,CAAC,iBAAiB,CAC7B,OAA0C,EAC1C,OAA4B,EAC5B,UAAiC;YAEjC,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;YAE1D,OAAO,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,IAAI,KAAK,CAAC;QACtD,CAAC;QAED,IAAW,UAAU;YACnB,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC;QAC3B,CAAC;QAED,gBAAgB;QACT,aAAa,CAAC,UAA0C;YAC7D,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YAEhC,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QAC1C,CAAC;KACF;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;GAGG;AACH,WAAiB,gBAAgB;IAC/B;;;;;;;;OAQG;IACH,SAAgB,aAAa,CAAC,OAAgB;QAC5C,OAAO,OAAO,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;IAC7C,CAAC;IAFe,8BAAa,gBAE5B,CAAA;AACH,CAAC,EAbgB,gBAAgB,KAAhB,gBAAgB,QAahC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nimport type { ApiItem, IApiItemJson, IApiItemConstructor, IApiItemOptions } from '../items/ApiItem';\nimport type { DeserializerContext } from '../model/DeserializerContext';\n\n/**\n * Constructor options for {@link (ApiReadonlyMixin:interface)}.\n * @public\n */\nexport interface IApiReadonlyMixinOptions extends IApiItemOptions {\n  isReadonly: boolean;\n}\n\nexport interface IApiReadonlyMixinJson extends IApiItemJson {\n  isReadonly: boolean;\n}\n\nconst _isReadonly: unique symbol = Symbol('ApiReadonlyMixin._isReadonly');\n\n/**\n * The mixin base class for API items that cannot be modified after instantiation.\n * Examples such as the readonly modifier and only having a getter but no setter.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.  The non-abstract classes (e.g. `ApiClass`, `ApiEnum`, `ApiInterface`, etc.) use\n * TypeScript \"mixin\" functions (e.g. `ApiDeclaredItem`, `ApiItemContainerMixin`, etc.) to add various\n * features that cannot be represented as a normal inheritance chain (since TypeScript does not allow a child class\n * to extend more than one base class).  The \"mixin\" is a TypeScript merged declaration with three components:\n * the function that generates a subclass, an interface that describes the members of the subclass, and\n * a namespace containing static members of the class.\n *\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport interface ApiReadonlyMixin extends ApiItem {\n  /**\n   * Indicates that the API item's value cannot be assigned by an external consumer.\n   *\n   * @remarks\n   * Examples of API items that would be considered \"read only\" by API Extractor:\n   *\n   * - A class or interface's property that has the `readonly` modifier.\n   *\n   * - A variable that has the `const` modifier.\n   *\n   * - A property or variable whose TSDoc comment includes the `@readonly` tag.\n   *\n   * - A property declaration with a getter but no setter.\n   *\n   * Note that if the `readonly` keyword appears in a type annotation, this does not\n   * guarantee that that the API item will be considered readonly. For example:\n   *\n   * ```ts\n   * declare class C {\n   *   // isReadonly=false in this case, because C.x is assignable\n   *   public x: readonly string[];\n   * }\n   * ```\n   */\n  readonly isReadonly: boolean;\n\n  serializeInto(jsonObject: Partial<IApiItemJson>): void;\n}\n\n/**\n * Mixin function for {@link (ApiReadonlyMixin:interface)}.\n *\n * @param baseClass - The base class to be extended\n * @returns A child class that extends baseClass, adding the {@link (ApiReadonlyMixin:interface)}\n * functionality.\n *\n * @public\n */\nexport function ApiReadonlyMixin<TBaseClass extends IApiItemConstructor>(\n  baseClass: TBaseClass\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): TBaseClass & (new (...args: any[]) => ApiReadonlyMixin) {\n  class MixedClass extends baseClass implements ApiReadonlyMixin {\n    public [_isReadonly]: boolean;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    public constructor(...args: any[]) {\n      super(...args);\n\n      const options: IApiReadonlyMixinOptions = args[0];\n      this[_isReadonly] = options.isReadonly;\n    }\n\n    /** @override */\n    public static onDeserializeInto(\n      options: Partial<IApiReadonlyMixinOptions>,\n      context: DeserializerContext,\n      jsonObject: IApiReadonlyMixinJson\n    ): void {\n      baseClass.onDeserializeInto(options, context, jsonObject);\n\n      options.isReadonly = jsonObject.isReadonly || false;\n    }\n\n    public get isReadonly(): boolean {\n      return this[_isReadonly];\n    }\n\n    /** @override */\n    public serializeInto(jsonObject: Partial<IApiReadonlyMixinJson>): void {\n      super.serializeInto(jsonObject);\n\n      jsonObject.isReadonly = this.isReadonly;\n    }\n  }\n\n  return MixedClass;\n}\n\n/**\n * Static members for {@link (ApiReadonlyMixin:interface)}.\n * @public\n */\nexport namespace ApiReadonlyMixin {\n  /**\n   * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiReadonlyMixin` mixin.\n   *\n   * @remarks\n   *\n   * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of\n   * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however\n   * the TypeScript type system cannot invoke a runtime test.)\n   */\n  export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiReadonlyMixin {\n    return apiItem.hasOwnProperty(_isReadonly);\n  }\n}\n"]}

package/lib-esm/mixins/ApiReleaseTagMixin.js

@@ -0,0 +1,65 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+/* eslint-disable @typescript-eslint/no-redeclare */
+import { Enum } from '@rushstack/node-core-library';
+import { ReleaseTag } from '../aedoc/ReleaseTag';
+const _releaseTag = Symbol('ApiReleaseTagMixin._releaseTag');
+/**
+ * Mixin function for {@link (ApiReleaseTagMixin:interface)}.
+ *
+ * @param baseClass - The base class to be extended
+ * @returns A child class that extends baseClass, adding the {@link (ApiReleaseTagMixin:interface)} functionality.
+ *
+ * @public
+ */
+export function ApiReleaseTagMixin(baseClass
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    class MixedClass extends baseClass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            const options = args[0];
+            this[_releaseTag] = options.releaseTag;
+        }
+        /** @override */
+        static onDeserializeInto(options, context, jsonObject) {
+            baseClass.onDeserializeInto(options, context, jsonObject);
+            const deserializedReleaseTag = Enum.tryGetValueByKey(ReleaseTag, // eslint-disable-line
+            jsonObject.releaseTag);
+            if (deserializedReleaseTag === undefined) {
+                throw new Error(`Failed to deserialize release tag ${JSON.stringify(jsonObject.releaseTag)}`);
+            }
+            options.releaseTag = deserializedReleaseTag;
+        }
+        get releaseTag() {
+            return this[_releaseTag];
+        }
+        /** @override */
+        serializeInto(jsonObject) {
+            super.serializeInto(jsonObject);
+            jsonObject.releaseTag = ReleaseTag[this.releaseTag];
+        }
+    }
+    return MixedClass;
+}
+/**
+ * Static members for {@link (ApiReleaseTagMixin:interface)}.
+ * @public
+ */
+(function (ApiReleaseTagMixin) {
+    /**
+     * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiReleaseTagMixin` mixin.
+     *
+     * @remarks
+     *
+     * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of
+     * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however
+     * the TypeScript type system cannot invoke a runtime test.)
+     */
+    function isBaseClassOf(apiItem) {
+        return apiItem.hasOwnProperty(_releaseTag);
+    }
+    ApiReleaseTagMixin.isBaseClassOf = isBaseClassOf;
+})(ApiReleaseTagMixin || (ApiReleaseTagMixin = {}));
+//# sourceMappingURL=ApiReleaseTagMixin.js.map

package/lib-esm/mixins/ApiReleaseTagMixin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiReleaseTagMixin.js","sourceRoot":"","sources":["../../src/mixins/ApiReleaseTagMixin.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAE3D,oDAAoD;AAEpD,OAAO,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAGpD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAejD,MAAM,WAAW,GAAkB,MAAM,CAAC,gCAAgC,CAAC,CAAC;AAiC5E;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,SAAqB;AACrB,8DAA8D;;IAE9D,MAAM,UAAW,SAAQ,SAAS;QAGhC,8DAA8D;QAC9D,YAAmB,GAAG,IAAW;YAC/B,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;YAEf,MAAM,OAAO,GAA+B,IAAI,CAAC,CAAC,CAAC,CAAC;YACpD,IAAI,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC;QACzC,CAAC;QAED,gBAAgB;QACT,MAAM,CAAC,iBAAiB,CAC7B,OAA4C,EAC5C,OAA4B,EAC5B,UAAmC;YAEnC,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;YAE1D,MAAM,sBAAsB,GAA2B,IAAI,CAAC,gBAAgB,CAC1E,UAAiB,EAAE,sBAAsB;YACzC,UAAU,CAAC,UAAU,CACtB,CAAC;YACF,IAAI,sBAAsB,KAAK,SAAS,EAAE,CAAC;gBACzC,MAAM,IAAI,KAAK,CAAC,qCAAqC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YAChG,CAAC;YAED,OAAO,CAAC,UAAU,GAAG,sBAAsB,CAAC;QAC9C,CAAC;QAED,IAAW,UAAU;YACnB,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC;QAC3B,CAAC;QAED,gBAAgB;QACT,aAAa,CAAC,UAA4C;YAC/D,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YAEhC,UAAU,CAAC,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACtD,CAAC;KACF;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;GAGG;AACH,WAAiB,kBAAkB;IACjC;;;;;;;;OAQG;IACH,SAAgB,aAAa,CAAC,OAAgB;QAC5C,OAAO,OAAO,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;IAC7C,CAAC;IAFe,gCAAa,gBAE5B,CAAA;AACH,CAAC,EAbgB,kBAAkB,KAAlB,kBAAkB,QAalC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nimport { Enum } from '@rushstack/node-core-library';\n\nimport type { ApiItem, IApiItemJson, IApiItemConstructor, IApiItemOptions } from '../items/ApiItem';\nimport { ReleaseTag } from '../aedoc/ReleaseTag';\nimport type { DeserializerContext } from '../model/DeserializerContext';\n\n/**\n * Constructor options for {@link (ApiReleaseTagMixin:interface)}.\n * @public\n */\nexport interface IApiReleaseTagMixinOptions extends IApiItemOptions {\n  releaseTag: ReleaseTag;\n}\n\nexport interface IApiReleaseTagMixinJson extends IApiItemJson {\n  releaseTag: string;\n}\n\nconst _releaseTag: unique symbol = Symbol('ApiReleaseTagMixin._releaseTag');\n\n/**\n * The mixin base class for API items that can be attributed with a TSDoc tag such as `@internal`,\n * `@alpha`, `@beta`, or `@public`.  These \"release tags\" indicate the support level for an API.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.  The non-abstract classes (e.g. `ApiClass`, `ApiEnum`, `ApiInterface`, etc.) use\n * TypeScript \"mixin\" functions (e.g. `ApiDeclaredItem`, `ApiItemContainerMixin`, etc.) to add various\n * features that cannot be represented as a normal inheritance chain (since TypeScript does not allow a child class\n * to extend more than one base class).  The \"mixin\" is a TypeScript merged declaration with three components:\n * the function that generates a subclass, an interface that describes the members of the subclass, and\n * a namespace containing static members of the class.\n *\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport interface ApiReleaseTagMixin extends ApiItem {\n  /**\n   * The effective release tag for this declaration.  If it is not explicitly specified, the value may be\n   * inherited from a containing declaration.\n   *\n   * @remarks\n   * For example, an `ApiEnumMember` may inherit its release tag from the containing `ApiEnum`.\n   */\n  readonly releaseTag: ReleaseTag;\n\n  /** @override */\n  serializeInto(jsonObject: Partial<IApiItemJson>): void;\n}\n\n/**\n * Mixin function for {@link (ApiReleaseTagMixin:interface)}.\n *\n * @param baseClass - The base class to be extended\n * @returns A child class that extends baseClass, adding the {@link (ApiReleaseTagMixin:interface)} functionality.\n *\n * @public\n */\nexport function ApiReleaseTagMixin<TBaseClass extends IApiItemConstructor>(\n  baseClass: TBaseClass\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): TBaseClass & (new (...args: any[]) => ApiReleaseTagMixin) {\n  class MixedClass extends baseClass implements ApiReleaseTagMixin {\n    public [_releaseTag]: ReleaseTag;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    public constructor(...args: any[]) {\n      super(...args);\n\n      const options: IApiReleaseTagMixinOptions = args[0];\n      this[_releaseTag] = options.releaseTag;\n    }\n\n    /** @override */\n    public static onDeserializeInto(\n      options: Partial<IApiReleaseTagMixinOptions>,\n      context: DeserializerContext,\n      jsonObject: IApiReleaseTagMixinJson\n    ): void {\n      baseClass.onDeserializeInto(options, context, jsonObject);\n\n      const deserializedReleaseTag: ReleaseTag | undefined = Enum.tryGetValueByKey<ReleaseTag>(\n        ReleaseTag as any, // eslint-disable-line\n        jsonObject.releaseTag\n      );\n      if (deserializedReleaseTag === undefined) {\n        throw new Error(`Failed to deserialize release tag ${JSON.stringify(jsonObject.releaseTag)}`);\n      }\n\n      options.releaseTag = deserializedReleaseTag;\n    }\n\n    public get releaseTag(): ReleaseTag {\n      return this[_releaseTag];\n    }\n\n    /** @override */\n    public serializeInto(jsonObject: Partial<IApiReleaseTagMixinJson>): void {\n      super.serializeInto(jsonObject);\n\n      jsonObject.releaseTag = ReleaseTag[this.releaseTag];\n    }\n  }\n\n  return MixedClass;\n}\n\n/**\n * Static members for {@link (ApiReleaseTagMixin:interface)}.\n * @public\n */\nexport namespace ApiReleaseTagMixin {\n  /**\n   * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiReleaseTagMixin` mixin.\n   *\n   * @remarks\n   *\n   * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of\n   * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however\n   * the TypeScript type system cannot invoke a runtime test.)\n   */\n  export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiReleaseTagMixin {\n    return apiItem.hasOwnProperty(_releaseTag);\n  }\n}\n"]}

package/lib-esm/mixins/ApiReturnTypeMixin.js

@@ -0,0 +1,65 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+/* eslint-disable @typescript-eslint/no-redeclare */
+import { InternalError } from '@rushstack/node-core-library';
+import { ApiDeclaredItem } from '../items/ApiDeclaredItem';
+const _returnTypeExcerpt = Symbol('ApiReturnTypeMixin._returnTypeExcerpt');
+/**
+ * Mixin function for {@link (ApiReturnTypeMixin:interface)}.
+ *
+ * @param baseClass - The base class to be extended
+ * @returns A child class that extends baseClass, adding the {@link (ApiReturnTypeMixin:interface)} functionality.
+ *
+ * @public
+ */
+export function ApiReturnTypeMixin(baseClass
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    class MixedClass extends baseClass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            const options = args[0];
+            if (this instanceof ApiDeclaredItem) {
+                this[_returnTypeExcerpt] = this.buildExcerpt(options.returnTypeTokenRange);
+            }
+            else {
+                throw new InternalError('ApiReturnTypeMixin expects a base class that inherits from ApiDeclaredItem');
+            }
+        }
+        /** @override */
+        static onDeserializeInto(options, context, jsonObject) {
+            baseClass.onDeserializeInto(options, context, jsonObject);
+            options.returnTypeTokenRange = jsonObject.returnTypeTokenRange;
+        }
+        get returnTypeExcerpt() {
+            return this[_returnTypeExcerpt];
+        }
+        /** @override */
+        serializeInto(jsonObject) {
+            super.serializeInto(jsonObject);
+            jsonObject.returnTypeTokenRange = this.returnTypeExcerpt.tokenRange;
+        }
+    }
+    return MixedClass;
+}
+/**
+ * Static members for {@link (ApiReturnTypeMixin:interface)}.
+ * @public
+ */
+(function (ApiReturnTypeMixin) {
+    /**
+     * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiReturnTypeMixin` mixin.
+     *
+     * @remarks
+     *
+     * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of
+     * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however
+     * the TypeScript type system cannot invoke a runtime test.)
+     */
+    function isBaseClassOf(apiItem) {
+        return apiItem.hasOwnProperty(_returnTypeExcerpt);
+    }
+    ApiReturnTypeMixin.isBaseClassOf = isBaseClassOf;
+})(ApiReturnTypeMixin || (ApiReturnTypeMixin = {}));
+//# sourceMappingURL=ApiReturnTypeMixin.js.map

package/lib-esm/mixins/ApiReturnTypeMixin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiReturnTypeMixin.js","sourceRoot":"","sources":["../../src/mixins/ApiReturnTypeMixin.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAE3D,oDAAoD;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAI7D,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAe3D,MAAM,kBAAkB,GAAkB,MAAM,CAAC,uCAAuC,CAAC,CAAC;AA4B1F;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,SAAqB;AACrB,8DAA8D;;IAE9D,MAAM,UAAW,SAAQ,SAAS;QAGhC,8DAA8D;QAC9D,YAAmB,GAAG,IAAW;YAC/B,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;YAEf,MAAM,OAAO,GAA+B,IAAI,CAAC,CAAC,CAAC,CAAC;YAEpD,IAAI,IAAI,YAAY,eAAe,EAAE,CAAC;gBACpC,IAAI,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;YAC7E,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,aAAa,CAAC,4EAA4E,CAAC,CAAC;YACxG,CAAC;QACH,CAAC;QAED,gBAAgB;QACT,MAAM,CAAC,iBAAiB,CAC7B,OAA4C,EAC5C,OAA4B,EAC5B,UAAmC;YAEnC,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;YAE1D,OAAO,CAAC,oBAAoB,GAAG,UAAU,CAAC,oBAAoB,CAAC;QACjE,CAAC;QAED,IAAW,iBAAiB;YAC1B,OAAO,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAClC,CAAC;QAED,gBAAgB;QACT,aAAa,CAAC,UAA4C;YAC/D,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YAEhC,UAAU,CAAC,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC;QACtE,CAAC;KACF;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;GAGG;AACH,WAAiB,kBAAkB;IACjC;;;;;;;;OAQG;IACH,SAAgB,aAAa,CAAC,OAAgB;QAC5C,OAAO,OAAO,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC;IACpD,CAAC;IAFe,gCAAa,gBAE5B,CAAA;AACH,CAAC,EAbgB,kBAAkB,KAAlB,kBAAkB,QAalC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nimport { InternalError } from '@rushstack/node-core-library';\n\nimport type { ApiItem, IApiItemJson, IApiItemConstructor, IApiItemOptions } from '../items/ApiItem';\nimport type { IExcerptTokenRange, Excerpt } from './Excerpt';\nimport { ApiDeclaredItem } from '../items/ApiDeclaredItem';\nimport type { DeserializerContext } from '../model/DeserializerContext';\n\n/**\n * Constructor options for {@link (ApiReturnTypeMixin:interface)}.\n * @public\n */\nexport interface IApiReturnTypeMixinOptions extends IApiItemOptions {\n  returnTypeTokenRange: IExcerptTokenRange;\n}\n\nexport interface IApiReturnTypeMixinJson extends IApiItemJson {\n  returnTypeTokenRange: IExcerptTokenRange;\n}\n\nconst _returnTypeExcerpt: unique symbol = Symbol('ApiReturnTypeMixin._returnTypeExcerpt');\n\n/**\n * The mixin base class for API items that are functions that return a value.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.  The non-abstract classes (e.g. `ApiClass`, `ApiEnum`, `ApiInterface`, etc.) use\n * TypeScript \"mixin\" functions (e.g. `ApiDeclaredItem`, `ApiItemContainerMixin`, etc.) to add various\n * features that cannot be represented as a normal inheritance chain (since TypeScript does not allow a child class\n * to extend more than one base class).  The \"mixin\" is a TypeScript merged declaration with three components:\n * the function that generates a subclass, an interface that describes the members of the subclass, and\n * a namespace containing static members of the class.\n *\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport interface ApiReturnTypeMixin extends ApiItem {\n  /**\n   * An {@link Excerpt} that describes the type of the function's return value.\n   */\n  readonly returnTypeExcerpt: Excerpt;\n\n  /** @override */\n  serializeInto(jsonObject: Partial<IApiReturnTypeMixinJson>): void;\n}\n\n/**\n * Mixin function for {@link (ApiReturnTypeMixin:interface)}.\n *\n * @param baseClass - The base class to be extended\n * @returns A child class that extends baseClass, adding the {@link (ApiReturnTypeMixin:interface)} functionality.\n *\n * @public\n */\nexport function ApiReturnTypeMixin<TBaseClass extends IApiItemConstructor>(\n  baseClass: TBaseClass\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): TBaseClass & (new (...args: any[]) => ApiReturnTypeMixin) {\n  class MixedClass extends baseClass implements ApiReturnTypeMixin {\n    public [_returnTypeExcerpt]: Excerpt;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    public constructor(...args: any[]) {\n      super(...args);\n\n      const options: IApiReturnTypeMixinOptions = args[0];\n\n      if (this instanceof ApiDeclaredItem) {\n        this[_returnTypeExcerpt] = this.buildExcerpt(options.returnTypeTokenRange);\n      } else {\n        throw new InternalError('ApiReturnTypeMixin expects a base class that inherits from ApiDeclaredItem');\n      }\n    }\n\n    /** @override */\n    public static onDeserializeInto(\n      options: Partial<IApiReturnTypeMixinOptions>,\n      context: DeserializerContext,\n      jsonObject: IApiReturnTypeMixinJson\n    ): void {\n      baseClass.onDeserializeInto(options, context, jsonObject);\n\n      options.returnTypeTokenRange = jsonObject.returnTypeTokenRange;\n    }\n\n    public get returnTypeExcerpt(): Excerpt {\n      return this[_returnTypeExcerpt];\n    }\n\n    /** @override */\n    public serializeInto(jsonObject: Partial<IApiReturnTypeMixinJson>): void {\n      super.serializeInto(jsonObject);\n\n      jsonObject.returnTypeTokenRange = this.returnTypeExcerpt.tokenRange;\n    }\n  }\n\n  return MixedClass;\n}\n\n/**\n * Static members for {@link (ApiReturnTypeMixin:interface)}.\n * @public\n */\nexport namespace ApiReturnTypeMixin {\n  /**\n   * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiReturnTypeMixin` mixin.\n   *\n   * @remarks\n   *\n   * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of\n   * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however\n   * the TypeScript type system cannot invoke a runtime test.)\n   */\n  export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiReturnTypeMixin {\n    return apiItem.hasOwnProperty(_returnTypeExcerpt);\n  }\n}\n"]}

package/lib-esm/mixins/ApiStaticMixin.js

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+const _isStatic = Symbol('ApiStaticMixin._isStatic');
+/**
+ * Mixin function for {@link (ApiStaticMixin:interface)}.
+ *
+ * @param baseClass - The base class to be extended
+ * @returns A child class that extends baseClass, adding the {@link (ApiStaticMixin:interface)} functionality.
+ *
+ * @public
+ */
+export function ApiStaticMixin(baseClass
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    class MixedClass extends baseClass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            const options = args[0];
+            this[_isStatic] = options.isStatic;
+        }
+        /** @override */
+        static onDeserializeInto(options, context, jsonObject) {
+            baseClass.onDeserializeInto(options, context, jsonObject);
+            options.isStatic = jsonObject.isStatic;
+        }
+        get isStatic() {
+            return this[_isStatic];
+        }
+        /** @override */
+        serializeInto(jsonObject) {
+            super.serializeInto(jsonObject);
+            jsonObject.isStatic = this.isStatic;
+        }
+    }
+    return MixedClass;
+}
+/**
+ * Static members for {@link (ApiStaticMixin:interface)}.
+ * @public
+ */
+(function (ApiStaticMixin) {
+    /**
+     * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiStaticMixin` mixin.
+     *
+     * @remarks
+     *
+     * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of
+     * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however
+     * the TypeScript type system cannot invoke a runtime test.)
+     */
+    function isBaseClassOf(apiItem) {
+        return apiItem.hasOwnProperty(_isStatic);
+    }
+    ApiStaticMixin.isBaseClassOf = isBaseClassOf;
+})(ApiStaticMixin || (ApiStaticMixin = {}));
+//# sourceMappingURL=ApiStaticMixin.js.map

package/lib-esm/mixins/ApiStaticMixin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiStaticMixin.js","sourceRoot":"","sources":["../../src/mixins/ApiStaticMixin.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAmB3D,MAAM,SAAS,GAAkB,MAAM,CAAC,0BAA0B,CAAC,CAAC;AA4BpE;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAC5B,SAAqB;AACrB,8DAA8D;;IAE9D,MAAM,UAAW,SAAQ,SAAS;QAGhC,8DAA8D;QAC9D,YAAmB,GAAG,IAAW;YAC/B,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;YAEf,MAAM,OAAO,GAA2B,IAAI,CAAC,CAAC,CAAC,CAAC;YAChD,IAAI,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC;QACrC,CAAC;QAED,gBAAgB;QACT,MAAM,CAAC,iBAAiB,CAC7B,OAAwC,EACxC,OAA4B,EAC5B,UAA+B;YAE/B,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;YAE1D,OAAO,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;QACzC,CAAC;QAED,IAAW,QAAQ;YACjB,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC;QACzB,CAAC;QAED,gBAAgB;QACT,aAAa,CAAC,UAAwC;YAC3D,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YAEhC,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QACtC,CAAC;KACF;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;GAGG;AACH,WAAiB,cAAc;IAC7B;;;;;;;;OAQG;IACH,SAAgB,aAAa,CAAC,OAAgB;QAC5C,OAAO,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;IAFe,4BAAa,gBAE5B,CAAA;AACH,CAAC,EAbgB,cAAc,KAAd,cAAc,QAa9B","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nimport type { ApiItem, IApiItemJson, IApiItemConstructor, IApiItemOptions } from '../items/ApiItem';\nimport type { DeserializerContext } from '../model/DeserializerContext';\n\n/**\n * Constructor options for {@link (IApiStaticMixinOptions:interface)}.\n * @public\n */\nexport interface IApiStaticMixinOptions extends IApiItemOptions {\n  isStatic: boolean;\n}\n\nexport interface IApiStaticMixinJson extends IApiItemJson {\n  isStatic: boolean;\n}\n\nconst _isStatic: unique symbol = Symbol('ApiStaticMixin._isStatic');\n\n/**\n * The mixin base class for API items that can have the TypeScript `static` keyword applied to them.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.  The non-abstract classes (e.g. `ApiClass`, `ApiEnum`, `ApiInterface`, etc.) use\n * TypeScript \"mixin\" functions (e.g. `ApiDeclaredItem`, `ApiItemContainerMixin`, etc.) to add various\n * features that cannot be represented as a normal inheritance chain (since TypeScript does not allow a child class\n * to extend more than one base class).  The \"mixin\" is a TypeScript merged declaration with three components:\n * the function that generates a subclass, an interface that describes the members of the subclass, and\n * a namespace containing static members of the class.\n *\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport interface ApiStaticMixin extends ApiItem {\n  /**\n   * Whether the declaration has the TypeScript `static` keyword.\n   */\n  readonly isStatic: boolean;\n\n  /** @override */\n  serializeInto(jsonObject: Partial<IApiItemJson>): void;\n}\n\n/**\n * Mixin function for {@link (ApiStaticMixin:interface)}.\n *\n * @param baseClass - The base class to be extended\n * @returns A child class that extends baseClass, adding the {@link (ApiStaticMixin:interface)} functionality.\n *\n * @public\n */\nexport function ApiStaticMixin<TBaseClass extends IApiItemConstructor>(\n  baseClass: TBaseClass\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): TBaseClass & (new (...args: any[]) => ApiStaticMixin) {\n  class MixedClass extends baseClass implements ApiStaticMixin {\n    public [_isStatic]: boolean;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    public constructor(...args: any[]) {\n      super(...args);\n\n      const options: IApiStaticMixinOptions = args[0];\n      this[_isStatic] = options.isStatic;\n    }\n\n    /** @override */\n    public static onDeserializeInto(\n      options: Partial<IApiStaticMixinOptions>,\n      context: DeserializerContext,\n      jsonObject: IApiStaticMixinJson\n    ): void {\n      baseClass.onDeserializeInto(options, context, jsonObject);\n\n      options.isStatic = jsonObject.isStatic;\n    }\n\n    public get isStatic(): boolean {\n      return this[_isStatic];\n    }\n\n    /** @override */\n    public serializeInto(jsonObject: Partial<IApiStaticMixinJson>): void {\n      super.serializeInto(jsonObject);\n\n      jsonObject.isStatic = this.isStatic;\n    }\n  }\n\n  return MixedClass;\n}\n\n/**\n * Static members for {@link (ApiStaticMixin:interface)}.\n * @public\n */\nexport namespace ApiStaticMixin {\n  /**\n   * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiStaticMixin` mixin.\n   *\n   * @remarks\n   *\n   * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of\n   * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however\n   * the TypeScript type system cannot invoke a runtime test.)\n   */\n  export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiStaticMixin {\n    return apiItem.hasOwnProperty(_isStatic);\n  }\n}\n"]}

package/lib-esm/mixins/ApiTypeParameterListMixin.js

@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+/* eslint-disable @typescript-eslint/no-redeclare */
+import { InternalError } from '@rushstack/node-core-library';
+import { TypeParameter } from '../model/TypeParameter';
+import { ApiDeclaredItem } from '../items/ApiDeclaredItem';
+const _typeParameters = Symbol('ApiTypeParameterListMixin._typeParameters');
+/**
+ * Mixin function for {@link (ApiTypeParameterListMixin:interface)}.
+ *
+ * @param baseClass - The base class to be extended
+ * @returns A child class that extends baseClass, adding the {@link (ApiTypeParameterListMixin:interface)}
+ * functionality.
+ *
+ * @public
+ */
+export function ApiTypeParameterListMixin(baseClass
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    class MixedClass extends baseClass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            const options = args[0];
+            this[_typeParameters] = [];
+            if (this instanceof ApiDeclaredItem) {
+                if (options.typeParameters) {
+                    for (const typeParameterOptions of options.typeParameters) {
+                        const defaultTypeExcerpt = this.buildExcerpt(typeParameterOptions.defaultTypeTokenRange);
+                        const typeParameter = new TypeParameter({
+                            name: typeParameterOptions.typeParameterName,
+                            constraintExcerpt: this.buildExcerpt(typeParameterOptions.constraintTokenRange),
+                            defaultTypeExcerpt,
+                            isOptional: !defaultTypeExcerpt.isEmpty,
+                            parent: this
+                        });
+                        this[_typeParameters].push(typeParameter);
+                    }
+                }
+            }
+            else {
+                throw new InternalError('ApiTypeParameterListMixin expects a base class that inherits from ApiDeclaredItem');
+            }
+        }
+        /** @override */
+        static onDeserializeInto(options, context, jsonObject) {
+            baseClass.onDeserializeInto(options, context, jsonObject);
+            options.typeParameters = jsonObject.typeParameters || [];
+        }
+        get typeParameters() {
+            return this[_typeParameters];
+        }
+        /** @override */
+        serializeInto(jsonObject) {
+            super.serializeInto(jsonObject);
+            const typeParameterObjects = [];
+            for (const typeParameter of this.typeParameters) {
+                typeParameterObjects.push({
+                    typeParameterName: typeParameter.name,
+                    constraintTokenRange: typeParameter.constraintExcerpt.tokenRange,
+                    defaultTypeTokenRange: typeParameter.defaultTypeExcerpt.tokenRange
+                });
+            }
+            if (typeParameterObjects.length > 0) {
+                jsonObject.typeParameters = typeParameterObjects;
+            }
+        }
+    }
+    return MixedClass;
+}
+/**
+ * Static members for {@link (ApiTypeParameterListMixin:interface)}.
+ * @public
+ */
+(function (ApiTypeParameterListMixin) {
+    /**
+     * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiParameterListMixin` mixin.
+     *
+     * @remarks
+     *
+     * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of
+     * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however
+     * the TypeScript type system cannot invoke a runtime test.)
+     */
+    function isBaseClassOf(apiItem) {
+        return apiItem.hasOwnProperty(_typeParameters);
+    }
+    ApiTypeParameterListMixin.isBaseClassOf = isBaseClassOf;
+})(ApiTypeParameterListMixin || (ApiTypeParameterListMixin = {}));
+//# sourceMappingURL=ApiTypeParameterListMixin.js.map

package/lib-esm/mixins/ApiTypeParameterListMixin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiTypeParameterListMixin.js","sourceRoot":"","sources":["../../src/mixins/ApiTypeParameterListMixin.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAE3D,oDAAoD;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAI7D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAyB3D,MAAM,eAAe,GAAkB,MAAM,CAAC,2CAA2C,CAAC,CAAC;AA2B3F;;;;;;;;GAQG;AACH,MAAM,UAAU,yBAAyB,CACvC,SAAqB;AACrB,8DAA8D;;IAE9D,MAAM,UAAW,SAAQ,SAAS;QAGhC,8DAA8D;QAC9D,YAAmB,GAAG,IAAW;YAC/B,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;YAEf,MAAM,OAAO,GAAsC,IAAI,CAAC,CAAC,CAAC,CAAC;YAE3D,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;YAE3B,IAAI,IAAI,YAAY,eAAe,EAAE,CAAC;gBACpC,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;oBAC3B,KAAK,MAAM,oBAAoB,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;wBAC1D,MAAM,kBAAkB,GAAY,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAC,qBAAqB,CAAC,CAAC;wBAClG,MAAM,aAAa,GAAkB,IAAI,aAAa,CAAC;4BACrD,IAAI,EAAE,oBAAoB,CAAC,iBAAiB;4BAC5C,iBAAiB,EAAE,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAC,oBAAoB,CAAC;4BAC/E,kBAAkB;4BAClB,UAAU,EAAE,CAAC,kBAAkB,CAAC,OAAO;4BACvC,MAAM,EAAE,IAAI;yBACb,CAAC,CAAC;wBAEH,IAAI,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;oBAC5C,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,aAAa,CACrB,mFAAmF,CACpF,CAAC;YACJ,CAAC;QACH,CAAC;QAED,gBAAgB;QACT,MAAM,CAAC,iBAAiB,CAC7B,OAAmD,EACnD,OAA4B,EAC5B,UAA0C;YAE1C,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;YAE1D,OAAO,CAAC,cAAc,GAAG,UAAU,CAAC,cAAc,IAAI,EAAE,CAAC;QAC3D,CAAC;QAED,IAAW,cAAc;YACvB,OAAO,IAAI,CAAC,eAAe,CAAC,CAAC;QAC/B,CAAC;QAED,gBAAgB;QACT,aAAa,CAAC,UAAmD;YACtE,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YAEhC,MAAM,oBAAoB,GAA+B,EAAE,CAAC;YAC5D,KAAK,MAAM,aAAa,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;gBAChD,oBAAoB,CAAC,IAAI,CAAC;oBACxB,iBAAiB,EAAE,aAAa,CAAC,IAAI;oBACrC,oBAAoB,EAAE,aAAa,CAAC,iBAAiB,CAAC,UAAU;oBAChE,qBAAqB,EAAE,aAAa,CAAC,kBAAkB,CAAC,UAAU;iBACnE,CAAC,CAAC;YACL,CAAC;YAED,IAAI,oBAAoB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpC,UAAU,CAAC,cAAc,GAAG,oBAAoB,CAAC;YACnD,CAAC;QACH,CAAC;KACF;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;GAGG;AACH,WAAiB,yBAAyB;IACxC;;;;;;;;OAQG;IACH,SAAgB,aAAa,CAAC,OAAgB;QAC5C,OAAO,OAAO,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC;IACjD,CAAC;IAFe,uCAAa,gBAE5B,CAAA;AACH,CAAC,EAbgB,yBAAyB,KAAzB,yBAAyB,QAazC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nimport { InternalError } from '@rushstack/node-core-library';\n\nimport type { ApiItem, IApiItemJson, IApiItemConstructor, IApiItemOptions } from '../items/ApiItem';\nimport type { Excerpt, IExcerptTokenRange } from './Excerpt';\nimport { TypeParameter } from '../model/TypeParameter';\nimport { ApiDeclaredItem } from '../items/ApiDeclaredItem';\nimport type { DeserializerContext } from '../model/DeserializerContext';\n\n/**\n * Represents parameter information that is part of {@link IApiTypeParameterListMixinOptions}\n * @public\n */\nexport interface IApiTypeParameterOptions {\n  typeParameterName: string;\n  constraintTokenRange: IExcerptTokenRange;\n  defaultTypeTokenRange: IExcerptTokenRange;\n}\n\n/**\n * Constructor options for {@link (ApiTypeParameterListMixin:interface)}.\n * @public\n */\nexport interface IApiTypeParameterListMixinOptions extends IApiItemOptions {\n  typeParameters: IApiTypeParameterOptions[];\n}\n\nexport interface IApiTypeParameterListMixinJson extends IApiItemJson {\n  typeParameters: IApiTypeParameterOptions[];\n}\n\nconst _typeParameters: unique symbol = Symbol('ApiTypeParameterListMixin._typeParameters');\n\n/**\n * The mixin base class for API items that can have type parameters.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.  The non-abstract classes (e.g. `ApiClass`, `ApiEnum`, `ApiInterface`, etc.) use\n * TypeScript \"mixin\" functions (e.g. `ApiDeclaredItem`, `ApiItemContainerMixin`, etc.) to add various\n * features that cannot be represented as a normal inheritance chain (since TypeScript does not allow a child class\n * to extend more than one base class).  The \"mixin\" is a TypeScript merged declaration with three components:\n * the function that generates a subclass, an interface that describes the members of the subclass, and\n * a namespace containing static members of the class.\n *\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport interface ApiTypeParameterListMixin extends ApiItem {\n  /**\n   * The type parameters.\n   */\n  readonly typeParameters: ReadonlyArray<TypeParameter>;\n\n  serializeInto(jsonObject: Partial<IApiItemJson>): void;\n}\n\n/**\n * Mixin function for {@link (ApiTypeParameterListMixin:interface)}.\n *\n * @param baseClass - The base class to be extended\n * @returns A child class that extends baseClass, adding the {@link (ApiTypeParameterListMixin:interface)}\n * functionality.\n *\n * @public\n */\nexport function ApiTypeParameterListMixin<TBaseClass extends IApiItemConstructor>(\n  baseClass: TBaseClass\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): TBaseClass & (new (...args: any[]) => ApiTypeParameterListMixin) {\n  class MixedClass extends baseClass implements ApiTypeParameterListMixin {\n    public readonly [_typeParameters]: TypeParameter[];\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    public constructor(...args: any[]) {\n      super(...args);\n\n      const options: IApiTypeParameterListMixinOptions = args[0];\n\n      this[_typeParameters] = [];\n\n      if (this instanceof ApiDeclaredItem) {\n        if (options.typeParameters) {\n          for (const typeParameterOptions of options.typeParameters) {\n            const defaultTypeExcerpt: Excerpt = this.buildExcerpt(typeParameterOptions.defaultTypeTokenRange);\n            const typeParameter: TypeParameter = new TypeParameter({\n              name: typeParameterOptions.typeParameterName,\n              constraintExcerpt: this.buildExcerpt(typeParameterOptions.constraintTokenRange),\n              defaultTypeExcerpt,\n              isOptional: !defaultTypeExcerpt.isEmpty,\n              parent: this\n            });\n\n            this[_typeParameters].push(typeParameter);\n          }\n        }\n      } else {\n        throw new InternalError(\n          'ApiTypeParameterListMixin expects a base class that inherits from ApiDeclaredItem'\n        );\n      }\n    }\n\n    /** @override */\n    public static onDeserializeInto(\n      options: Partial<IApiTypeParameterListMixinOptions>,\n      context: DeserializerContext,\n      jsonObject: IApiTypeParameterListMixinJson\n    ): void {\n      baseClass.onDeserializeInto(options, context, jsonObject);\n\n      options.typeParameters = jsonObject.typeParameters || [];\n    }\n\n    public get typeParameters(): ReadonlyArray<TypeParameter> {\n      return this[_typeParameters];\n    }\n\n    /** @override */\n    public serializeInto(jsonObject: Partial<IApiTypeParameterListMixinJson>): void {\n      super.serializeInto(jsonObject);\n\n      const typeParameterObjects: IApiTypeParameterOptions[] = [];\n      for (const typeParameter of this.typeParameters) {\n        typeParameterObjects.push({\n          typeParameterName: typeParameter.name,\n          constraintTokenRange: typeParameter.constraintExcerpt.tokenRange,\n          defaultTypeTokenRange: typeParameter.defaultTypeExcerpt.tokenRange\n        });\n      }\n\n      if (typeParameterObjects.length > 0) {\n        jsonObject.typeParameters = typeParameterObjects;\n      }\n    }\n  }\n\n  return MixedClass;\n}\n\n/**\n * Static members for {@link (ApiTypeParameterListMixin:interface)}.\n * @public\n */\nexport namespace ApiTypeParameterListMixin {\n  /**\n   * A type guard that tests whether the specified `ApiItem` subclass extends the `ApiParameterListMixin` mixin.\n   *\n   * @remarks\n   *\n   * The JavaScript `instanceof` operator cannot be used to test for mixin inheritance, because each invocation of\n   * the mixin function produces a different subclass.  (This could be mitigated by `Symbol.hasInstance`, however\n   * the TypeScript type system cannot invoke a runtime test.)\n   */\n  export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiTypeParameterListMixin {\n    return apiItem.hasOwnProperty(_typeParameters);\n  }\n}\n"]}

package/lib-esm/mixins/Excerpt.js

@@ -0,0 +1,101 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+import { Text } from '@rushstack/node-core-library';
+/** @public */
+export var ExcerptTokenKind;
+(function (ExcerptTokenKind) {
+    /**
+     * Generic text without any special properties
+     */
+    ExcerptTokenKind["Content"] = "Content";
+    /**
+     * A reference to an API declaration
+     */
+    ExcerptTokenKind["Reference"] = "Reference";
+})(ExcerptTokenKind || (ExcerptTokenKind = {}));
+/**
+ * Represents a fragment of text belonging to an {@link Excerpt} object.
+ *
+ * @public
+ */
+export class ExcerptToken {
+    constructor(kind, text, canonicalReference) {
+        this._kind = kind;
+        // Standardize the newlines across operating systems. Even though this may deviate from the actual
+        // input source file that was parsed, it's useful because the newline gets serialized inside
+        // a string literal in .api.json, which cannot be automatically normalized by Git.
+        this._text = Text.convertToLf(text);
+        this._canonicalReference = canonicalReference;
+    }
+    /**
+     * Indicates the kind of token.
+     */
+    get kind() {
+        return this._kind;
+    }
+    /**
+     * The text fragment.
+     */
+    get text() {
+        return this._text;
+    }
+    /**
+     * The hyperlink target for a token whose type is `ExcerptTokenKind.Reference`.  For other token types,
+     * this property will be `undefined`.
+     */
+    get canonicalReference() {
+        return this._canonicalReference;
+    }
+}
+/**
+ * The `Excerpt` class is used by {@link ApiDeclaredItem} to represent a TypeScript code fragment that may be
+ * annotated with hyperlinks to declared types (and in the future, source code locations).
+ *
+ * @remarks
+ * API Extractor's .api.json file format stores excerpts compactly as a start/end indexes into an array of tokens.
+ * Every `ApiDeclaredItem` has a "main excerpt" corresponding to the full list of tokens.  The declaration may
+ * also have have "captured" excerpts that correspond to subranges of tokens.
+ *
+ * For example, if the main excerpt is:
+ *
+ * ```
+ * function parse(s: string): Vector | undefined;
+ * ```
+ *
+ * ...then this entire signature is the "main excerpt", whereas the function's return type `Vector | undefined` is a
+ * captured excerpt.  The `Vector` token might be a hyperlink to that API item.
+ *
+ * An excerpt may be empty (i.e. a token range containing zero tokens).  For example, if a function's return value
+ * is not explicitly declared, then the returnTypeExcerpt will be empty.  By contrast, a class constructor cannot
+ * have a return value, so ApiConstructor has no returnTypeExcerpt property at all.
+ *
+ * @public
+ */
+export class Excerpt {
+    constructor(tokens, tokenRange) {
+        this.tokens = tokens;
+        this.tokenRange = tokenRange;
+        if (this.tokenRange.startIndex < 0 ||
+            this.tokenRange.endIndex > this.tokens.length ||
+            this.tokenRange.startIndex > this.tokenRange.endIndex) {
+            throw new Error('Invalid token range');
+        }
+        this.spannedTokens = this.tokens.slice(this.tokenRange.startIndex, this.tokenRange.endIndex);
+    }
+    /**
+     * The excerpted text, formed by concatenating the text of the `spannedTokens` strings.
+     */
+    get text() {
+        if (this._text === undefined) {
+            this._text = this.spannedTokens.map((x) => x.text).join('');
+        }
+        return this._text;
+    }
+    /**
+     * Returns true if the excerpt is an empty range.
+     */
+    get isEmpty() {
+        return this.tokenRange.startIndex === this.tokenRange.endIndex;
+    }
+}
+//# sourceMappingURL=Excerpt.js.map

package/lib-esm/mixins/Excerpt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Excerpt.js","sourceRoot":"","sources":["../../src/mixins/Excerpt.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAG3D,OAAO,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAEpD,cAAc;AACd,MAAM,CAAN,IAAY,gBAUX;AAVD,WAAY,gBAAgB;IAC1B;;OAEG;IACH,uCAAmB,CAAA;IAEnB;;OAEG;IACH,2CAAuB,CAAA;AACzB,CAAC,EAVW,gBAAgB,KAAhB,gBAAgB,QAU3B;AA8BD;;;;GAIG;AACH,MAAM,OAAO,YAAY;IAKvB,YAAmB,IAAsB,EAAE,IAAY,EAAE,kBAAyC;QAChG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAElB,kGAAkG;QAClG,4FAA4F;QAC5F,kFAAkF;QAClF,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,mBAAmB,GAAG,kBAAkB,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;OAEG;IACH,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;;OAGG;IACH,IAAW,kBAAkB;QAC3B,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,OAAO,OAAO;IAqBlB,YAAmB,MAAmC,EAAE,UAA8B;QACpF,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAE7B,IACE,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,CAAC;YAC9B,IAAI,CAAC,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM;YAC7C,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,EACrD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QAED,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IAC/F,CAAC;IAED;;OAEG;IACH,IAAW,IAAI;QACb,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;OAEG;IACH,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC,UAAU,KAAK,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;IACjE,CAAC;CACF","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport type { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { Text } from '@rushstack/node-core-library';\n\n/** @public */\nexport enum ExcerptTokenKind {\n  /**\n   * Generic text without any special properties\n   */\n  Content = 'Content',\n\n  /**\n   * A reference to an API declaration\n   */\n  Reference = 'Reference'\n}\n\n/**\n * Used by {@link Excerpt} to indicate a range of indexes within an array of `ExcerptToken` objects.\n *\n * @public\n */\nexport interface IExcerptTokenRange {\n  /**\n   * The starting index of the span.\n   */\n  startIndex: number;\n\n  /**\n   * The index of the last member of the span, plus one.\n   *\n   * @remarks\n   *\n   * If `startIndex` and `endIndex` are the same number, then the span is empty.\n   */\n  endIndex: number;\n}\n\n/** @public */\nexport interface IExcerptToken {\n  readonly kind: ExcerptTokenKind;\n  text: string;\n  canonicalReference?: string;\n}\n\n/**\n * Represents a fragment of text belonging to an {@link Excerpt} object.\n *\n * @public\n */\nexport class ExcerptToken {\n  private readonly _kind: ExcerptTokenKind;\n  private readonly _text: string;\n  private readonly _canonicalReference: DeclarationReference | undefined;\n\n  public constructor(kind: ExcerptTokenKind, text: string, canonicalReference?: DeclarationReference) {\n    this._kind = kind;\n\n    // Standardize the newlines across operating systems. Even though this may deviate from the actual\n    // input source file that was parsed, it's useful because the newline gets serialized inside\n    // a string literal in .api.json, which cannot be automatically normalized by Git.\n    this._text = Text.convertToLf(text);\n    this._canonicalReference = canonicalReference;\n  }\n\n  /**\n   * Indicates the kind of token.\n   */\n  public get kind(): ExcerptTokenKind {\n    return this._kind;\n  }\n\n  /**\n   * The text fragment.\n   */\n  public get text(): string {\n    return this._text;\n  }\n\n  /**\n   * The hyperlink target for a token whose type is `ExcerptTokenKind.Reference`.  For other token types,\n   * this property will be `undefined`.\n   */\n  public get canonicalReference(): DeclarationReference | undefined {\n    return this._canonicalReference;\n  }\n}\n\n/**\n * The `Excerpt` class is used by {@link ApiDeclaredItem} to represent a TypeScript code fragment that may be\n * annotated with hyperlinks to declared types (and in the future, source code locations).\n *\n * @remarks\n * API Extractor's .api.json file format stores excerpts compactly as a start/end indexes into an array of tokens.\n * Every `ApiDeclaredItem` has a \"main excerpt\" corresponding to the full list of tokens.  The declaration may\n * also have have \"captured\" excerpts that correspond to subranges of tokens.\n *\n * For example, if the main excerpt is:\n *\n * ```\n * function parse(s: string): Vector | undefined;\n * ```\n *\n * ...then this entire signature is the \"main excerpt\", whereas the function's return type `Vector | undefined` is a\n * captured excerpt.  The `Vector` token might be a hyperlink to that API item.\n *\n * An excerpt may be empty (i.e. a token range containing zero tokens).  For example, if a function's return value\n * is not explicitly declared, then the returnTypeExcerpt will be empty.  By contrast, a class constructor cannot\n * have a return value, so ApiConstructor has no returnTypeExcerpt property at all.\n *\n * @public\n */\nexport class Excerpt {\n  /**\n   * The complete list of tokens for the source code fragment that this excerpt is based upon.\n   * If this object is the main excerpt, then it will span all of the tokens; otherwise, it will correspond to\n   * a range within the array.\n   */\n  public readonly tokens: ReadonlyArray<ExcerptToken>;\n\n  /**\n   * Specifies the excerpt's range within the `tokens` array.\n   */\n  public readonly tokenRange: Readonly<IExcerptTokenRange>;\n\n  /**\n   * The tokens spanned by this excerpt.  It is the range of the `tokens` array as specified by the `tokenRange`\n   * property.\n   */\n  public readonly spannedTokens: ReadonlyArray<ExcerptToken>;\n\n  private _text: string | undefined;\n\n  public constructor(tokens: ReadonlyArray<ExcerptToken>, tokenRange: IExcerptTokenRange) {\n    this.tokens = tokens;\n    this.tokenRange = tokenRange;\n\n    if (\n      this.tokenRange.startIndex < 0 ||\n      this.tokenRange.endIndex > this.tokens.length ||\n      this.tokenRange.startIndex > this.tokenRange.endIndex\n    ) {\n      throw new Error('Invalid token range');\n    }\n\n    this.spannedTokens = this.tokens.slice(this.tokenRange.startIndex, this.tokenRange.endIndex);\n  }\n\n  /**\n   * The excerpted text, formed by concatenating the text of the `spannedTokens` strings.\n   */\n  public get text(): string {\n    if (this._text === undefined) {\n      this._text = this.spannedTokens.map((x) => x.text).join('');\n    }\n    return this._text;\n  }\n\n  /**\n   * Returns true if the excerpt is an empty range.\n   */\n  public get isEmpty(): boolean {\n    return this.tokenRange.startIndex === this.tokenRange.endIndex;\n  }\n}\n"]}

package/lib-esm/mixins/IFindApiItemsResult.js

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+/**
+ * Unique identifiers for messages returned as part of `IFindApiItemsResult`.
+ * @public
+ */
+export var FindApiItemsMessageId;
+(function (FindApiItemsMessageId) {
+    /**
+     * "Unable to resolve declaration reference within API item ___: ___"
+     */
+    FindApiItemsMessageId["DeclarationResolutionFailed"] = "declaration-resolution-failed";
+    /**
+     * "Unable to analyze extends clause ___ of API item ___ because no canonical reference was found."
+     */
+    FindApiItemsMessageId["ExtendsClauseMissingReference"] = "extends-clause-missing-reference";
+    /**
+     * "Unable to analyze references of API item ___ because it is not associated with an ApiModel"
+     */
+    FindApiItemsMessageId["NoAssociatedApiModel"] = "no-associated-api-model";
+    /**
+     * "Unable to analyze references of API item ___ because it is of unsupported kind ___"
+     */
+    FindApiItemsMessageId["UnsupportedKind"] = "unsupported-kind";
+})(FindApiItemsMessageId || (FindApiItemsMessageId = {}));
+//# sourceMappingURL=IFindApiItemsResult.js.map