## API Report File for "@microsoft/api-extractor-model"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
import { DocDeclarationReference } from '@microsoft/tsdoc';
import { IJsonFileSaveOptions } from '@rushstack/node-core-library';
import { JsonObject } from '@rushstack/node-core-library';
import * as tsdoc from '@microsoft/tsdoc';
import { TSDocConfiguration } from '@microsoft/tsdoc';
import { TSDocTagDefinition } from '@microsoft/tsdoc';

// Warning: (ae-internal-missing-underscore) The name "AedocDefinitions" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal @deprecated (undocumented)
export class AedocDefinitions {
    // (undocumented)
    static readonly betaDocumentation: TSDocTagDefinition;
    // (undocumented)
    static readonly internalRemarks: TSDocTagDefinition;
    // (undocumented)
    static readonly preapprovedTag: TSDocTagDefinition;
    // (undocumented)
    static get tsdocConfiguration(): TSDocConfiguration;
}

// @public
export function ApiAbstractMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiAbstractMixin);

// @public
export interface ApiAbstractMixin extends ApiItem {
    readonly isAbstract: boolean;
    // Warning: (ae-forgotten-export) The symbol "IApiItemJson" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
}

// @public
export namespace ApiAbstractMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiAbstractMixin;
}

// Warning: (ae-forgotten-export) The symbol "ApiCallSignature_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiCallSignature extends ApiCallSignature_base {
    constructor(options: IApiCallSignatureOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(overloadIndex: number): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// Warning: (ae-forgotten-export) The symbol "ApiClass_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiClass extends ApiClass_base {
    constructor(options: IApiClassOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    readonly extendsType: HeritageType | undefined;
    // (undocumented)
    static getContainerKey(name: string): string;
    get implementsTypes(): ReadonlyArray<HeritageType>;
    // @override (undocumented)
    get kind(): ApiItemKind;
    // Warning: (ae-forgotten-export) The symbol "DeserializerContext" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "IApiClassJson" needs to be exported by the entry point index.d.ts
    //
    // @override (undocumented)
    static onDeserializeInto(options: Partial<IApiClassOptions>, context: DeserializerContext, jsonObject: IApiClassJson): void;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiClassJson>): void;
}

// Warning: (ae-forgotten-export) The symbol "ApiConstructor_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiConstructor extends ApiConstructor_base {
    constructor(options: IApiConstructorOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(overloadIndex: number): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// Warning: (ae-forgotten-export) The symbol "ApiConstructSignature_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiConstructSignature extends ApiConstructSignature_base {
    constructor(options: IApiConstructSignatureOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(overloadIndex: number): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// @public
export class ApiDeclaredItem extends ApiDocumentedItem {
    constructor(options: IApiDeclaredItemOptions);
    buildExcerpt(tokenRange: IExcerptTokenRange): Excerpt;
    get excerpt(): Excerpt;
    get excerptTokens(): ReadonlyArray<ExcerptToken>;
    get fileUrlPath(): string | undefined;
    getExcerptWithModifiers(): string;
    // Warning: (ae-forgotten-export) The symbol "IApiDeclaredItemJson" needs to be exported by the entry point index.d.ts
    //
    // @override (undocumented)
    static onDeserializeInto(options: Partial<IApiDeclaredItemOptions>, context: DeserializerContext, jsonObject: IApiDeclaredItemJson): void;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiDeclaredItemJson>): void;
    get sourceLocation(): SourceLocation;
}

// @public
export class ApiDocumentedItem extends ApiItem {
    constructor(options: IApiDocumentedItemOptions);
    // @override (undocumented)
    static onDeserializeInto(options: Partial<IApiDocumentedItemOptions>, context: DeserializerContext, jsonObject: IApiItemJson): void;
    // Warning: (ae-forgotten-export) The symbol "IApiDocumentedItemJson" needs to be exported by the entry point index.d.ts
    //
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiDocumentedItemJson>): void;
    // (undocumented)
    get tsdocComment(): tsdoc.DocComment | undefined;
}

// Warning: (ae-forgotten-export) The symbol "ApiEntryPoint_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiEntryPoint extends ApiEntryPoint_base {
    constructor(options: IApiEntryPointOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    get importPath(): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// Warning: (ae-forgotten-export) The symbol "ApiEnum_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiEnum extends ApiEnum_base {
    constructor(options: IApiEnumOptions);
    // @override (undocumented)
    addMember(member: ApiEnumMember): void;
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(name: string): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
    // @override (undocumented)
    get members(): ReadonlyArray<ApiEnumMember>;
}

// Warning: (ae-forgotten-export) The symbol "ApiEnumMember_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiEnumMember extends ApiEnumMember_base {
    constructor(options: IApiEnumMemberOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(name: string): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// @public
export function ApiExportedMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiExportedMixin);

// @public
export interface ApiExportedMixin extends ApiItem {
    readonly isExported: boolean;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
}

// @public
export namespace ApiExportedMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiExportedMixin;
}

// Warning: (ae-forgotten-export) The symbol "ApiFunction_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiFunction extends ApiFunction_base {
    constructor(options: IApiFunctionOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(name: string, overloadIndex: number): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// Warning: (ae-forgotten-export) The symbol "ApiIndexSignature_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiIndexSignature extends ApiIndexSignature_base {
    constructor(options: IApiIndexSignatureOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(overloadIndex: number): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// @public
export function ApiInitializerMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiInitializerMixin);

// @public
export interface ApiInitializerMixin extends ApiItem {
    readonly initializerExcerpt?: Excerpt;
    // Warning: (ae-forgotten-export) The symbol "IApiInitializerMixinJson" needs to be exported by the entry point index.d.ts
    //
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiInitializerMixinJson>): void;
}

// @public
export namespace ApiInitializerMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiInitializerMixin;
}

// Warning: (ae-forgotten-export) The symbol "ApiInterface_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiInterface extends ApiInterface_base {
    constructor(options: IApiInterfaceOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    get extendsTypes(): ReadonlyArray<HeritageType>;
    // (undocumented)
    static getContainerKey(name: string): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
    // Warning: (ae-forgotten-export) The symbol "IApiInterfaceJson" needs to be exported by the entry point index.d.ts
    //
    // @override (undocumented)
    static onDeserializeInto(options: Partial<IApiInterfaceOptions>, context: DeserializerContext, jsonObject: IApiInterfaceJson): void;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiInterfaceJson>): void;
}

// @public
export class ApiItem {
    // @internal
    [apiItem_onParentChanged](parent: ApiItem | undefined): void;
    constructor(options: IApiItemOptions);
    // @virtual
    protected buildCanonicalReference(): DeclarationReference;
    // @beta
    get canonicalReference(): DeclarationReference;
    // @virtual
    get containerKey(): string;
    // (undocumented)
    static deserialize(jsonObject: IApiItemJson, context: DeserializerContext): ApiItem;
    // @virtual
    get displayName(): string;
    getAssociatedModel(): ApiModel | undefined;
    getAssociatedPackage(): ApiPackage | undefined;
    getHierarchy(): ReadonlyArray<ApiItem>;
    getMergedSiblings(): ReadonlyArray<ApiItem>;
    getScopedNameWithinPackage(): string;
    // @virtual
    getSortKey(): string;
    // @virtual
    get kind(): ApiItemKind;
    // @virtual
    get members(): ReadonlyArray<ApiItem>;
    // @virtual (undocumented)
    static onDeserializeInto(options: Partial<IApiItemOptions>, context: DeserializerContext, jsonObject: IApiItemJson): void;
    // @virtual
    get parent(): ApiItem | undefined;
    // @virtual (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
}

// @public
export function ApiItemContainerMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiItemContainerMixin);

// @public
export interface ApiItemContainerMixin extends ApiItem {
    addMember(member: ApiItem): void;
    findMembersByName(name: string): ReadonlyArray<ApiItem>;
    findMembersWithInheritance(): IFindApiItemsResult;
    // @internal
    _getMergedSiblingsForMember(memberApiItem: ApiItem): ReadonlyArray<ApiItem>;
    readonly preserveMemberOrder: boolean;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
    tryGetMemberByKey(containerKey: string): ApiItem | undefined;
}

// @public
export namespace ApiItemContainerMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiItemContainerMixin;
}

// @public
export enum ApiItemKind {
    // (undocumented)
    CallSignature = "CallSignature",
    // (undocumented)
    Class = "Class",
    // (undocumented)
    Constructor = "Constructor",
    // (undocumented)
    ConstructSignature = "ConstructSignature",
    // (undocumented)
    EntryPoint = "EntryPoint",
    // (undocumented)
    Enum = "Enum",
    // (undocumented)
    EnumMember = "EnumMember",
    // (undocumented)
    Function = "Function",
    // (undocumented)
    IndexSignature = "IndexSignature",
    // (undocumented)
    Interface = "Interface",
    // (undocumented)
    Method = "Method",
    // (undocumented)
    MethodSignature = "MethodSignature",
    // (undocumented)
    Model = "Model",
    // (undocumented)
    Namespace = "Namespace",
    // (undocumented)
    None = "None",
    // (undocumented)
    Package = "Package",
    // (undocumented)
    Property = "Property",
    // (undocumented)
    PropertySignature = "PropertySignature",
    // (undocumented)
    TypeAlias = "TypeAlias",
    // (undocumented)
    Variable = "Variable"
}

// Warning: (ae-forgotten-export) The symbol "ApiMethod_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiMethod extends ApiMethod_base {
    constructor(options: IApiMethodOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(name: string, isStatic: boolean, overloadIndex: number): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// Warning: (ae-forgotten-export) The symbol "ApiMethodSignature_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiMethodSignature extends ApiMethodSignature_base {
    constructor(options: IApiMethodSignatureOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(name: string, overloadIndex: number): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// Warning: (ae-forgotten-export) The symbol "ApiModel_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiModel extends ApiModel_base {
    constructor();
    // @override (undocumented)
    addMember(member: ApiPackage): void;
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
    // (undocumented)
    loadPackage(apiJsonFilename: string): ApiPackage;
    // (undocumented)
    get packages(): ReadonlyArray<ApiPackage>;
    // (undocumented)
    resolveDeclarationReference(declarationReference: DocDeclarationReference | DeclarationReference, contextApiItem: ApiItem | undefined): IResolveDeclarationReferenceResult;
    tryGetPackageByName(packageName: string): ApiPackage | undefined;
}

// @public
export function ApiNameMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiNameMixin);

// @public
export interface ApiNameMixin extends ApiItem {
    readonly name: string;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
}

// @public
export namespace ApiNameMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiNameMixin;
}

// Warning: (ae-forgotten-export) The symbol "ApiNamespace_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiNamespace extends ApiNamespace_base {
    constructor(options: IApiNamespaceOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(name: string): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// @public
export function ApiOptionalMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiOptionalMixin);

// @public
export interface ApiOptionalMixin extends ApiItem {
    readonly isOptional: boolean;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
}

// @public
export namespace ApiOptionalMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiOptionalMixin;
}

// Warning: (ae-forgotten-export) The symbol "ApiPackage_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiPackage extends ApiPackage_base {
    constructor(options: IApiPackageOptions);
    // @override (undocumented)
    addMember(member: ApiEntryPoint): void;
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    get entryPoints(): ReadonlyArray<ApiEntryPoint>;
    // (undocumented)
    findEntryPointsByPath(importPath: string): ReadonlyArray<ApiEntryPoint>;
    // @override (undocumented)
    get kind(): ApiItemKind;
    // (undocumented)
    static loadFromJsonFile(apiJsonFilename: string): ApiPackage;
    // Warning: (ae-forgotten-export) The symbol "IApiPackageJson" needs to be exported by the entry point index.d.ts
    //
    // @override (undocumented)
    static onDeserializeInto(options: Partial<IApiPackageOptions>, context: DeserializerContext, jsonObject: IApiPackageJson): void;
    // (undocumented)
    get projectFolderUrl(): string | undefined;
    // (undocumented)
    saveToJsonFile(apiJsonFilename: string, options?: IApiPackageSaveOptions): void;
    get tsdocConfiguration(): TSDocConfiguration;
}

// @public
export function ApiParameterListMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiParameterListMixin);

// @public
export interface ApiParameterListMixin extends ApiItem {
    readonly overloadIndex: number;
    readonly parameters: ReadonlyArray<Parameter>;
    // (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
}

// @public
export namespace ApiParameterListMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiParameterListMixin;
}

// Warning: (ae-forgotten-export) The symbol "ApiProperty_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiProperty extends ApiProperty_base {
    constructor(options: IApiPropertyOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(name: string, isStatic: boolean): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// Warning: (ae-forgotten-export) The symbol "ApiPropertyItem_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiPropertyItem extends ApiPropertyItem_base {
    constructor(options: IApiPropertyItemOptions);
    get isEventProperty(): boolean;
    // Warning: (ae-forgotten-export) The symbol "IApiPropertyItemJson" needs to be exported by the entry point index.d.ts
    //
    // @override (undocumented)
    static onDeserializeInto(options: Partial<IApiPropertyItemOptions>, context: DeserializerContext, jsonObject: IApiPropertyItemJson): void;
    readonly propertyTypeExcerpt: Excerpt;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiPropertyItemJson>): void;
}

// @public
export class ApiPropertySignature extends ApiPropertyItem {
    constructor(options: IApiPropertySignatureOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(name: string): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
}

// @public
export function ApiProtectedMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiProtectedMixin);

// @public
export interface ApiProtectedMixin extends ApiItem {
    readonly isProtected: boolean;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
}

// @public
export namespace ApiProtectedMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiProtectedMixin;
}

// @public
export function ApiReadonlyMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiReadonlyMixin);

// @public
export interface ApiReadonlyMixin extends ApiItem {
    readonly isReadonly: boolean;
    // (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
}

// @public
export namespace ApiReadonlyMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiReadonlyMixin;
}

// @public
export function ApiReleaseTagMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiReleaseTagMixin);

// @public
export interface ApiReleaseTagMixin extends ApiItem {
    readonly releaseTag: ReleaseTag;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
}

// @public
export namespace ApiReleaseTagMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiReleaseTagMixin;
}

// @public
export function ApiReturnTypeMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiReturnTypeMixin);

// @public
export interface ApiReturnTypeMixin extends ApiItem {
    readonly returnTypeExcerpt: Excerpt;
    // Warning: (ae-forgotten-export) The symbol "IApiReturnTypeMixinJson" needs to be exported by the entry point index.d.ts
    //
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiReturnTypeMixinJson>): void;
}

// @public
export namespace ApiReturnTypeMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiReturnTypeMixin;
}

// @public
export function ApiStaticMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiStaticMixin);

// @public
export interface ApiStaticMixin extends ApiItem {
    readonly isStatic: boolean;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
}

// @public
export namespace ApiStaticMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiStaticMixin;
}

// Warning: (ae-forgotten-export) The symbol "ApiTypeAlias_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiTypeAlias extends ApiTypeAlias_base {
    constructor(options: IApiTypeAliasOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(name: string): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
    // Warning: (ae-forgotten-export) The symbol "IApiTypeAliasJson" needs to be exported by the entry point index.d.ts
    //
    // @override (undocumented)
    static onDeserializeInto(options: Partial<IApiTypeAliasOptions>, context: DeserializerContext, jsonObject: IApiTypeAliasJson): void;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiTypeAliasJson>): void;
    readonly typeExcerpt: Excerpt;
}

// @public
export function ApiTypeParameterListMixin<TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => ApiTypeParameterListMixin);

// @public
export interface ApiTypeParameterListMixin extends ApiItem {
    // (undocumented)
    serializeInto(jsonObject: Partial<IApiItemJson>): void;
    readonly typeParameters: ReadonlyArray<TypeParameter>;
}

// @public
export namespace ApiTypeParameterListMixin {
    export function isBaseClassOf(apiItem: ApiItem): apiItem is ApiTypeParameterListMixin;
}

// Warning: (ae-forgotten-export) The symbol "ApiVariable_base" needs to be exported by the entry point index.d.ts
//
// @public
export class ApiVariable extends ApiVariable_base {
    constructor(options: IApiVariableOptions);
    // @beta @override (undocumented)
    buildCanonicalReference(): DeclarationReference;
    // @override (undocumented)
    get containerKey(): string;
    // (undocumented)
    static getContainerKey(name: string): string;
    // @override (undocumented)
    get kind(): ApiItemKind;
    // Warning: (ae-forgotten-export) The symbol "IApiVariableJson" needs to be exported by the entry point index.d.ts
    //
    // @override (undocumented)
    static onDeserializeInto(options: Partial<IApiVariableOptions>, context: DeserializerContext, jsonObject: IApiVariableJson): void;
    // @override (undocumented)
    serializeInto(jsonObject: Partial<IApiVariableJson>): void;
    readonly variableTypeExcerpt: Excerpt;
}

// @public
export type Constructor<T = {}> = new (...args: any[]) => T;

// @public
export enum EnumMemberOrder {
    ByName = "by-name",
    Preserve = "preserve"
}

// @public
export class Excerpt {
    constructor(tokens: ReadonlyArray<ExcerptToken>, tokenRange: IExcerptTokenRange);
    get isEmpty(): boolean;
    readonly spannedTokens: ReadonlyArray<ExcerptToken>;
    get text(): string;
    readonly tokenRange: Readonly<IExcerptTokenRange>;
    readonly tokens: ReadonlyArray<ExcerptToken>;
}

// @public
export class ExcerptToken {
    constructor(kind: ExcerptTokenKind, text: string, canonicalReference?: DeclarationReference);
    get canonicalReference(): DeclarationReference | undefined;
    get kind(): ExcerptTokenKind;
    get text(): string;
}

// @public (undocumented)
export enum ExcerptTokenKind {
    Content = "Content",
    Reference = "Reference"
}

// @public
export enum FindApiItemsMessageId {
    DeclarationResolutionFailed = "declaration-resolution-failed",
    ExtendsClauseMissingReference = "extends-clause-missing-reference",
    NoAssociatedApiModel = "no-associated-api-model",
    UnsupportedKind = "unsupported-kind"
}

// @public
export class HeritageType {
    constructor(excerpt: Excerpt);
    readonly excerpt: Excerpt;
}

// @public
export interface IApiAbstractMixinOptions extends IApiItemOptions {
    // (undocumented)
    isAbstract: boolean;
}

// @public
export interface IApiCallSignatureOptions extends IApiTypeParameterListMixinOptions, IApiParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiDeclaredItemOptions {
}

// @public
export interface IApiClassOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions, IApiAbstractMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiTypeParameterListMixinOptions, IApiExportedMixinOptions {
    // (undocumented)
    extendsTokenRange: IExcerptTokenRange | undefined;
    // (undocumented)
    implementsTokenRanges: IExcerptTokenRange[];
}

// @public
export interface IApiConstructorOptions extends IApiParameterListMixinOptions, IApiProtectedMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions {
}

// @public
export interface IApiConstructSignatureOptions extends IApiTypeParameterListMixinOptions, IApiParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiDeclaredItemOptions {
}

// @public
export interface IApiDeclaredItemOptions extends IApiDocumentedItemOptions {
    // (undocumented)
    excerptTokens: IExcerptToken[];
    // (undocumented)
    fileUrlPath?: string;
}

// @public
export interface IApiDocumentedItemOptions extends IApiItemOptions {
    // (undocumented)
    docComment: tsdoc.DocComment | undefined;
}

// @public
export interface IApiEntryPointOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions {
}

// @public
export interface IApiEnumMemberOptions extends IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiInitializerMixinOptions {
}

// @public
export interface IApiEnumOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiExportedMixinOptions {
}

// @public
export interface IApiExportedMixinOptions extends IApiItemOptions {
    // (undocumented)
    isExported: boolean;
}

// @public
export interface IApiFunctionOptions extends IApiNameMixinOptions, IApiTypeParameterListMixinOptions, IApiParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiDeclaredItemOptions, IApiExportedMixinOptions {
}

// @public
export interface IApiIndexSignatureOptions extends IApiParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiReadonlyMixinOptions, IApiDeclaredItemOptions {
}

// @public
export interface IApiInitializerMixinOptions extends IApiItemOptions {
    // (undocumented)
    initializerTokenRange?: IExcerptTokenRange;
}

// @public
export interface IApiInterfaceOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions, IApiTypeParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiExportedMixinOptions {
    // (undocumented)
    extendsTokenRanges: IExcerptTokenRange[];
}

// @public
export interface IApiItemConstructor extends Constructor<ApiItem>, PropertiesOf<typeof ApiItem> {
}

// @public
export interface IApiItemContainerMixinOptions extends IApiItemOptions {
    // (undocumented)
    members?: ApiItem[];
    // (undocumented)
    preserveMemberOrder?: boolean;
}

// @public
export interface IApiItemOptions {
}

// @public
export interface IApiMethodOptions extends IApiNameMixinOptions, IApiAbstractMixinOptions, IApiOptionalMixinOptions, IApiParameterListMixinOptions, IApiProtectedMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiStaticMixinOptions, IApiTypeParameterListMixinOptions, IApiDeclaredItemOptions {
}

// @public (undocumented)
export interface IApiMethodSignatureOptions extends IApiNameMixinOptions, IApiTypeParameterListMixinOptions, IApiParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiOptionalMixinOptions, IApiDeclaredItemOptions {
}

// @public
export interface IApiNameMixinOptions extends IApiItemOptions {
    // (undocumented)
    name: string;
}

// @public
export interface IApiNamespaceOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiExportedMixinOptions {
}

// @public
export interface IApiOptionalMixinOptions extends IApiItemOptions {
    // (undocumented)
    isOptional: boolean;
}

// @public
export interface IApiPackageOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions, IApiDocumentedItemOptions {
    // (undocumented)
    projectFolderUrl?: string;
    // (undocumented)
    tsdocConfiguration: TSDocConfiguration;
}

// @public
export interface IApiPackageSaveOptions extends IJsonFileSaveOptions {
    testMode?: boolean;
    toolPackage?: string;
    toolVersion?: string;
}

// @public
export interface IApiParameterListMixinOptions extends IApiItemOptions {
    // (undocumented)
    overloadIndex: number;
    // (undocumented)
    parameters: IApiParameterOptions[];
}

// @public
export interface IApiParameterOptions {
    // (undocumented)
    isOptional: boolean;
    // (undocumented)
    parameterName: string;
    // (undocumented)
    parameterTypeTokenRange: IExcerptTokenRange;
}

// @public
export interface IApiPropertyItemOptions extends IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiOptionalMixinOptions, IApiReadonlyMixinOptions, IApiDeclaredItemOptions {
    // (undocumented)
    propertyTypeTokenRange: IExcerptTokenRange;
}

// @public
export interface IApiPropertyOptions extends IApiPropertyItemOptions, IApiAbstractMixinOptions, IApiProtectedMixinOptions, IApiStaticMixinOptions, IApiInitializerMixinOptions {
}

// @public
export interface IApiPropertySignatureOptions extends IApiPropertyItemOptions {
}

// @public
export interface IApiProtectedMixinOptions extends IApiItemOptions {
    // (undocumented)
    isProtected: boolean;
}

// @public
export interface IApiReadonlyMixinOptions extends IApiItemOptions {
    // (undocumented)
    isReadonly: boolean;
}

// @public
export interface IApiReleaseTagMixinOptions extends IApiItemOptions {
    // (undocumented)
    releaseTag: ReleaseTag;
}

// @public
export interface IApiReturnTypeMixinOptions extends IApiItemOptions {
    // (undocumented)
    returnTypeTokenRange: IExcerptTokenRange;
}

// @public
export interface IApiStaticMixinOptions extends IApiItemOptions {
    // (undocumented)
    isStatic: boolean;
}

// @public
export interface IApiTypeAliasOptions extends IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiTypeParameterListMixinOptions, IApiExportedMixinOptions {
    // (undocumented)
    typeTokenRange: IExcerptTokenRange;
}

// @public
export interface IApiTypeParameterListMixinOptions extends IApiItemOptions {
    // (undocumented)
    typeParameters: IApiTypeParameterOptions[];
}

// @public
export interface IApiTypeParameterOptions {
    // (undocumented)
    constraintTokenRange: IExcerptTokenRange;
    // (undocumented)
    defaultTypeTokenRange: IExcerptTokenRange;
    // (undocumented)
    typeParameterName: string;
}

// @public
export interface IApiVariableOptions extends IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiReadonlyMixinOptions, IApiDeclaredItemOptions, IApiInitializerMixinOptions, IApiExportedMixinOptions {
    // (undocumented)
    variableTypeTokenRange: IExcerptTokenRange;
}

// @public (undocumented)
export interface IExcerptToken {
    // (undocumented)
    canonicalReference?: string;
    // (undocumented)
    readonly kind: ExcerptTokenKind;
    // (undocumented)
    text: string;
}

// @public
export interface IExcerptTokenRange {
    endIndex: number;
    startIndex: number;
}

// @public
export interface IFindApiItemsMessage {
    // @beta
    messageId: FindApiItemsMessageId;
    text: string;
}

// @public
export interface IFindApiItemsResult {
    items: ApiItem[];
    maybeIncompleteResult: boolean;
    messages: IFindApiItemsMessage[];
}

// @public
export interface IParameterOptions {
    // (undocumented)
    isOptional: boolean;
    // (undocumented)
    name: string;
    // (undocumented)
    parameterTypeExcerpt: Excerpt;
    // (undocumented)
    parent: ApiParameterListMixin;
}

// @public
export interface IResolveDeclarationReferenceResult {
    errorMessage: string | undefined;
    resolvedApiItem: ApiItem | undefined;
}

// @public
export interface ISourceLocationOptions {
    fileUrlPath?: string;
    projectFolderUrl?: string;
}

// @public
export interface ITypeParameterOptions {
    // (undocumented)
    constraintExcerpt: Excerpt;
    // (undocumented)
    defaultTypeExcerpt: Excerpt;
    // (undocumented)
    isOptional: boolean;
    // (undocumented)
    name: string;
    // (undocumented)
    parent: ApiTypeParameterListMixin;
}

// @public
export class Parameter {
    constructor(options: IParameterOptions);
    isOptional: boolean;
    name: string;
    readonly parameterTypeExcerpt: Excerpt;
    get tsdocParamBlock(): tsdoc.DocParamBlock | undefined;
}

// @public
export type PropertiesOf<T> = {
    [K in keyof T]: T[K];
};

// @public
export enum ReleaseTag {
    Alpha = 2,
    Beta = 3,
    Internal = 1,
    None = 0,
    Public = 4
}

// @public
export namespace ReleaseTag {
    export function compare(a: ReleaseTag, b: ReleaseTag): number;
    export function getTagName(releaseTag: ReleaseTag): string;
}

// @public
export class SourceLocation {
    constructor(options: ISourceLocationOptions);
    get fileUrl(): string | undefined;
}

// @public
export class TypeParameter {
    constructor(options: ITypeParameterOptions);
    readonly constraintExcerpt: Excerpt;
    readonly defaultTypeExcerpt: Excerpt;
    isOptional: boolean;
    name: string;
    get tsdocTypeParamBlock(): tsdoc.DocParamBlock | undefined;
}

```
