@arcgis/api-extractor 5.0.0-next.8 → 5.0.0-next.80

package/dist/internalTypeScriptApis.d.ts

@@ -0,0 +1,31 @@
+import { default as ts } from 'typescript';
+import { TransformResult } from 'vite';
+type SourceMap = Extract<NonNullable<TransformResult["map"]>, {
+    file: string;
+}>;
+export declare const unsafeUndocumentedTs: Required<UndocumentedTypeScript>;
+type UndocumentedTypeScript = {
+    readonly createSourceMapGenerator?: (host: ts.CompilerHost, basename: string, sourceRoot: string, dirname: string, compilerOptions: ts.CompilerOptions) => SourceMapGenerator;
+    readonly createTextWriter?: (newLine: string) => EmitTextWriter;
+    readonly getNewLineCharacter?: (options: ts.CompilerOptions) => string;
+    readonly createPrinter: (
+    /**
+     * Printer has undocumented options for printing source maps:
+     * https://github.com/microsoft/TypeScript/blob/7319968e90600102892a79142fb804bcbe384160/src/compiler/types.ts#L9689C18-L9707
+     */
+    options: ts.CompilerOptions & ts.PrinterOptions, handlers?: ts.PrintHandlers) => ReturnType<typeof ts.createPrinter> & UndocumentedPrinter;
+};
+type SourceMapGenerator = {
+    readonly toJSON: () => SourceMap;
+};
+type UndocumentedPrinter = {
+    readonly writeFile?: (writeFile: ts.SourceFile, writer: EmitTextWriter, sourceMapGenerator: SourceMapGenerator | undefined) => void;
+    writeNode?: (hint: ts.EmitHint, node: ts.Node, sourceFile: ts.SourceFile | undefined, output: EmitTextWriter) => void;
+};
+type EmitTextWriter = {
+    readonly getText: () => string;
+    readonly getTextPos: () => number;
+    readonly clear: () => void;
+};
+export declare function unsafeGetUndocumentedPrinter(compilerOptions: ts.CompilerOptions, handlers?: ts.PrintHandlers): ReturnType<typeof ts.createPrinter> & UndocumentedPrinter;
+export {};

package/dist/types.d.ts

@@ -1,25 +1,22 @@
-import { ApiCustomElementField, ApiCustomElementDeclaration, ApiClassMethod, ApiEvent } from './apiJson';
+import { ApiCustomElementDeclaration, ApiClassMethod, ApiEvent, ApiClassDeclaration, ApiFunctionDeclaration, ApiModule, ApiVariableDeclaration, ApiInterfaceDeclaration, ApiDocsTag, ApiCustomElementField, ApiWithDescription } from './apiJson.ts';
+export interface NodeDoc extends ApiWithDescription {
+    docsTags: ApiDocsTag[];
+}
 /**
- * @example
- * ```ts
- * {
- *   properties: {
- *     // You only need to return the fields you wish to modify.
- *     autoDestroyDisabled: () => ({
- *       description: `If true, the component will not be destroyed automatically when it is
- * disconnected from the document. This is useful when you want to move the
- * component to a different place on the page, or temporarily hide it. If this
- * is set, make sure to call the {@link #destroy} method when you are done to
- * prevent memory leaks.`,
- *     }),
- *   },
- * }
+ * [Documentation](https://webgis.esri.cm/arcgis-components/docs/max-jsapi-typings/webgis-project-docs/core/core/documenting-api#copydoc)
  */
 export type CopyDocDefinitions = {
-    properties?: Record<string, CopyPropertyDoc | undefined>;
-    methods?: Record<string, CopyMethodDoc | undefined>;
-    events?: Record<string, CopyEventDoc | undefined>;
+    properties?: CopyDocMemberDeclarations<ApiCustomElementField>;
+    methods?: CopyDocMemberDeclarations<ApiClassMethod>;
+    events?: CopyDocMemberDeclarations<ApiEvent>;
+    classes?: CopyDocDeclarations<ApiClassDeclaration>;
+    customElements?: CopyDocDeclarations<ApiCustomElementDeclaration>;
+    functions?: CopyDocDeclarations<ApiFunctionDeclaration>;
+    variables?: CopyDocDeclarations<ApiVariableDeclaration>;
+    /** This includes both type aliases and interfaces */
+    interfaces?: CopyDocDeclarations<ApiInterfaceDeclaration>;
 };
-export type CopyPropertyDoc = (property: ApiCustomElementField, component: ApiCustomElementDeclaration) => Partial<ApiCustomElementField> | undefined;
-export type CopyMethodDoc = (method: ApiClassMethod, component: ApiCustomElementDeclaration) => Partial<ApiClassMethod> | undefined;
-export type CopyEventDoc = (event: ApiEvent, component: ApiCustomElementDeclaration) => Partial<ApiEvent> | undefined;
+type CopiableFields = "deprecated" | "description" | "docsTags" | "readonly" | "return";
+type CopyDocDeclarations<ApiType extends Partial<Record<CopiableFields, unknown>>> = Record<string, Partial<Pick<ApiType, CopiableFields>> | ((apiDeclaration: ApiType, module: ApiModule) => Partial<Pick<ApiType, CopiableFields>>) | undefined>;
+type CopyDocMemberDeclarations<ApiType extends Partial<Record<CopiableFields, unknown>>> = Record<string, Partial<Pick<ApiType, CopiableFields>> | ((apiDeclaration: ApiType, classOrComponent: ApiClassDeclaration | ApiCustomElementDeclaration, module: ApiModule) => Partial<Pick<ApiType, CopiableFields>>) | undefined>;
+export {};

package/dist/uiUtils/index.d.ts

@@ -0,0 +1,21 @@
+import { ApiType, ApiTypeReference } from '../apiJson.ts';
+/**
+ * Traverse through ApiType text string, turning type references into links.
+ *
+ * Also hydrates well-known JS "global" keywords (e.g. `string`, `number`), even
+ * if they don't appear in ApiType.references.
+ *
+ * @example
+ * ```ts
+ * const markdownTypeString = hydrateApiType(
+ *   apiProperty.type,
+ *   (text, reference) => `[${text}](${reference.viewUrl})`
+ * ).join("");
+ * ```
+ *
+ * @see [Type References](../config/typeReferences/README.md)
+ */
+export declare function hydrateApiType<T>(apiType: Pick<ApiType, "references" | "text">, hydratePart: HydrateApiTypeCallback<T>): (T | string)[];
+export type HydrateApiTypeCallback<T> = (referenceText: string, reference: ApiTypeReference & {
+    viewUrl: NonNullable<ApiTypeReference["viewUrl"]>;
+}) => T;

package/dist/uiUtils/index.js

@@ -0,0 +1,57 @@
+const d = Object.assign(/* @__PURE__ */ Object.create(null), {
+  undefined: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/undefined",
+  string: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String",
+  boolean: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
+  null: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/null",
+  number: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number",
+  object: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object",
+  void: "https://www.typescriptlang.org/docs/handbook/2/functions.html#void",
+  unknown: "https://www.typescriptlang.org/docs/handbook/2/functions.html#unknown",
+  never: "https://www.typescriptlang.org/docs/handbook/2/functions.html#never",
+  any: "https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#any",
+  this: "#"
+}), h = Object.keys(d).join("|"), g = new RegExp(`\\b(?:${h})\\b`, "u");
+function p(e, l) {
+  const n = [];
+  let o = e.text.length;
+  if (e.references !== void 0)
+    for (let c = e.references.length - 1; c >= 0; c--) {
+      const t = e.references[c];
+      if (t.start === void 0 || t.end === void 0)
+        continue;
+      const r = e.text.slice(t.end, o);
+      r.length > 0 && i(r, l, n);
+      const s = e.text.slice(t.start, t.end);
+      o = t.start, t.viewUrl === void 0 ? n.push(s) : n.push(
+        l(s, t)
+      );
+    }
+  if (o > 0) {
+    const c = e.text.slice(0, o);
+    i(c, l, n);
+  }
+  return n.reverse();
+}
+function i(e, l, n) {
+  const o = n.length;
+  for (let c = 0; c < e.length; ) {
+    const t = e.match(g);
+    if (t?.index === void 0)
+      break;
+    const r = e.slice(0, t.index);
+    r.length > 0 && n.splice(o, 0, r);
+    const s = t[0];
+    e = e.slice(t.index + s.length);
+    const a = d[s], b = l(s, {
+      name: s,
+      module: void 0,
+      package: s === "this" ? void 0 : "global:",
+      viewUrl: a
+    });
+    n.splice(o, 0, b);
+  }
+  e.length > 0 && n.splice(o, 0, e);
+}
+export {
+  p as hydrateApiType
+};

package/dist/utils/apiHelpers.d.ts

@@ -1,4 +1,5 @@
-import { ApiClassMember, ApiClassMethod, ApiCustomElementField, ApiModule } from '../apiJson';
+import { default as ts } from 'typescript';
+import { ApiAttribute, ApiClassDeclaration, ApiClassMember, ApiClassMethod, ApiCssCustomProperty, ApiCssCustomState, ApiCssPart, ApiCustomElementDeclaration, ApiCustomElementField, ApiCustomElementMember, ApiDeclaration, ApiEvent, ApiFunctionDeclaration, ApiInterfaceDeclaration, ApiModule, ApiSlot, ApiTypeReference, ApiVariableDeclaration } from '../apiJson.ts';
 export declare const isApiMethod: (member: ApiClassMember) => member is ApiClassMethod;
 export declare const isApiProperty: (member: ApiClassMember) => member is ApiCustomElementField;
 /**
@@ -15,9 +16,67 @@ export declare const isApiProperty: (member: ApiClassMember) => member is ApiCus
  * ]
  * ```
  */
-export declare function naturalSortModules(left: ApiModule, right: ApiModule): number;
+export declare function naturalSortModules(left: Pick<ApiModule, "sourcePath">, right: Pick<ApiModule, "sourcePath">): number;
 /**
  * This is not made up by us - defined in the custom-elements-manifest spec
  */
 export declare const globalPackageIdentifier = "global:";
 export declare const multipleJsDocTags: Set<string>;
+interface PostProcessLinkContext {
+    alternativeDocumentationHost: string;
+    normalizedDocumentationHost: string;
+    resolveJsDocLink: (text: string, match: string) => string;
+    moduleName: string;
+    file?: ts.SourceFile;
+}
+export declare function postProcessLinks(apiPart: Partial<Pick<ApiCustomElementField, "deprecated" | "description" | "docsTags">>, context: PostProcessLinkContext): void;
+/**
+ * @privateRemarks
+ * Link validation runs during post-processing, at which point we don't have easy
+ * AST access.
+ */
+export declare function apiExtractorJsDocError(message: string, text: string, context: PostProcessLinkContext): void;
+export declare const compareStrings: (x: string, y: string) => number;
+export declare const compareNamedNodes: (left: {
+    name: string;
+}, right: {
+    name: string;
+}) => number;
+/**
+ * 1. Static members
+ * 2. Constructors and call signatures
+ * 3. Properties before methods
+ * 4. Alphabetical
+ */
+export declare const compareClassMembers: (left: ApiClassMember, right: ApiClassMember) => number;
+/**
+ * Associate a start and end index with each type reference. Drop unresolved
+ * references.
+ */
+export declare function findReferenceRanges(references: ApiTypeReference[], resolvedString: string): ApiTypeReference[] | undefined;
+/**
+ * Get a name from a class member.
+ *
+ * @example
+ * - method named "test" => "test"
+ * - property named "test" => "test"
+ * - constructor => "constructor"
+ * - call-signature => "call-signature"
+ */
+export declare const getApiMemberName: (member: ApiClassMember | ApiCustomElementMember) => string;
+/**
+ * Like `getApiMemberName`, but prefixes with `static ` if the member is static.
+ */
+export declare const getMaybeStaticApiMemberName: (member: ApiClassMember | ApiCustomElementMember) => string;
+/**
+ * Get a UI label from a class member.
+ *
+ * @example
+ * - method named "test" => "test()"
+ * - property named "test" => "test"
+ * - constructor => "constructor()"
+ * - call-signature => "()"
+ */
+export declare const getApiNodeLabel: (member: ApiClassMember | ApiCssCustomProperty | ApiCustomElementMember | ApiDeclaration | ApiEvent) => string;
+export declare function mergeApiNodes<T extends ApiAttribute | ApiClassDeclaration | ApiClassMember | ApiCssCustomProperty | ApiCssCustomState | ApiCssPart | ApiCustomElementDeclaration | ApiCustomElementMember | ApiEvent | ApiFunctionDeclaration | ApiInterfaceDeclaration | ApiSlot | ApiVariableDeclaration>(source: Partial<T>, destination: T, copyDocTagIndex?: number): void;
+export {};

package/dist/utils/astHelpers.d.ts

@@ -1,10 +1,17 @@
 import { default as ts } from 'typescript';
-import { ApiPropertyLike } from '../apiJson';
+import { ApiPropertyLike } from '../apiJson.ts';
 /**
  * Check if a member has a static, private, or protected modifier.
  */
 export declare const hasIgnoredModifier: (member: ts.ClassElement) => boolean;
-export declare function setDefaultFromInitializer(node: ts.AccessorDeclaration | ts.PropertyDeclaration, property: ApiPropertyLike, sourceFile: ts.SourceFile): void;
+/**
+ * Include default value only if:
+ * - it's a literal value
+ * - we have `@default` tag in the JSDoc (handled in setApiDocFromJsDoc)
+ * - default value is a variable or property access expression whose
+ *   declaration has a JSDoc (handled further down in this file)
+ */
+export declare function setDefaultFromInitializer(node: Pick<ts.PropertyDeclaration, "initializer">, property: Pick<ApiPropertyLike, "default">, sourceFile: ts.SourceFile): void;
 /**
  * Convert property name node into a string. Converts Identifier and
  * StringLiteralLike nodes. The rest return undefined.
@@ -13,3 +20,8 @@ export declare function getMemberName(name?: ts.PropertyName): string | undefine
 export declare const findDecorator: ({ modifiers }: {
     modifiers?: readonly ts.ModifierLike[];
 }, name: string) => ts.CallExpression | undefined;
+export declare function extractBooleanInitializer(initializer: ts.Expression, sourceFile: ts.SourceFile): boolean;
+/**
+ * Remove the first dot after the last slash. Thus, `.d.ts` is removed.
+ */
+export declare function getBasename(path: string): string;

package/dist/utils/error.d.ts

@@ -1,6 +1,6 @@
 import { default as ts } from 'typescript';
 export declare let apiExtractorErrorCount: number;
-export declare const apiExtractorErrorFiles: Set<string>;
+export declare function resetApiExtractorErrorCount(newCount?: number): void;
 export declare function setApiExtractorErrorLogger(logger: (msg: string) => void): void;
 export interface ApiExtractorErrorContext {
     file: ts.SourceFile | undefined;
@@ -9,4 +9,9 @@ export interface ApiExtractorErrorContext {
     start?: number;
     length?: number;
 }
+export declare const apiExtractorDiagnosticContext: ts.FormatDiagnosticsHost;
+/**
+ * Produce an error message in the style of TypeScript compiler errors.
+ * Error message includes code snippet when possible.
+ */
 export declare function apiExtractorError(message: string, { file, node, scope, start, length }: ApiExtractorErrorContext): void;

package/dist/utils/jsDocHelpers.d.ts

@@ -0,0 +1,2 @@
+export declare const normalizedDocumentationHost = "developers.arcgis.com";
+export declare const alternativeDocumentationHost = "next.gha.afd.arcgis.com";

package/dist/utils/jsDocParser.d.ts

@@ -0,0 +1,46 @@
+import { default as ts } from 'typescript';
+import { ApiCustomElementDeclaration, ApiCustomElementField } from '../apiJson.ts';
+import { NodeDoc } from '../types.ts';
+/**
+ * Find node's JSDoc comment and parse it into a NodeDoc
+ *
+ * @param node AST node that has leading JSDoc comment
+ * @param sourceFile Source file that contains the `node`
+ * @param ensureIsPublic If true (default), will return undefined if JSDoc does
+ * not contain a `@public` tag. In such cases, `@public` is not included in
+ * `NodeDoc` as it is assumed.
+ * @privateRemarks
+ * FINAL: adopt in Lumina
+ */
+export declare function getNodeDoc(node: ts.Node, sourceFile: ts.SourceFile, 
+/** @default true */
+ensureIsPublic?: boolean): NodeDoc | undefined;
+/**
+ * TypeScript parses too much around \@param, \@property and \@deprecated tags
+ * It also parses out inline tags. We have to put them back together
+ * (overhead and complexity). Plus, it is a bit too tolerant - we want
+ * to disallow some ambiguous behavior to improve consistency.
+ * And TypeScript incorrectly parses decorators as tags when used inside code
+ * snippets.
+ *
+ * Given all of the above, we implement a tiny, but strict JSDoc parser
+ *
+ * @param jsDocText JSDoc string that starts with /** and ends with *\/
+ * @param sourceFile Used for error reporting
+ * @param ensureIsPublic If true, will return undefined if JSDoc does not contain a \@public tag
+ */
+declare function parseJsDoc(jsDocText: string, sourceFile: ts.SourceFile, ensureIsPublic?: false): NodeDoc;
+declare function parseJsDoc(jsDocText: string, sourceFile: ts.SourceFile, ensureIsPublic: boolean): NodeDoc | undefined;
+/**
+ * @deprecated migrate to getNodeDoc
+ */
+export declare function symbolToDocs(checker: ts.TypeChecker, symbol: ts.Signature | ts.Symbol): NodeDoc;
+/**
+ * @deprecated migrate to getNodeDoc
+ */
+export declare function setApiDocFromSymbol(node: ts.PropertyName, checker: ts.TypeChecker, api: Partial<Pick<ApiCustomElementDeclaration, "cssParts" | "cssProperties" | "cssStates" | "slots"> & Pick<ApiCustomElementField, "default" | "deprecated" | "description" | "docsTags" | "privacy" | "readonly">>): void;
+export declare function setApiDocFromJsDoc(api: Partial<Pick<ApiCustomElementDeclaration, "cssParts" | "cssProperties" | "cssStates" | "slots"> & Pick<ApiCustomElementField, "default" | "deprecated" | "description" | "docsTags" | "privacy" | "readonly">>, docs: ReturnType<typeof symbolToDocs>): void;
+export declare const exportsForTests: {
+    parseJsDoc: typeof parseJsDoc;
+};
+export {};

package/dist/utils/jsDocPrinter.d.ts

@@ -0,0 +1,13 @@
+import { default as ts } from 'typescript';
+import { ApiEvent, ApiCustomElementMember, ApiDeclaration, ApiModule, ApiClassMember } from '../apiJson.ts';
+import { NodeDoc } from '../types.ts';
+export declare function apiMemberToNodeDoc(apiMember: ApiClassMember | ApiCustomElementMember | ApiDeclaration | ApiEvent | ApiModule): NodeDoc | undefined;
+export declare function nodeDocToSynthesizedComment(nodeDoc: NodeDoc | undefined): ts.SynthesizedComment[];
+/**
+ * Omitting leading /* and trailing *\/ as those will be inserted by TypeScript.
+ *
+ * @privateRemarks
+ * This function is in the hot path - called for every API item. To reduce memory
+ * churn, we avoid creating intermediate arrays inside.
+ */
+export declare function nodeDocToString(nodeDoc: NodeDoc): string;

package/dist/utils/partPrinter.d.ts

@@ -0,0 +1,23 @@
+import { ApiFunctionLike, ApiParameter, ApiTypeParameter } from '../apiJson.ts';
+export declare function printClass(isAbstract: boolean, 
+/**
+ * For consistency and to simplify the docs messaging, everything that appears
+ * in our .d.ts files is exported - non-public things don't appear in the .d.ts
+ * files.
+ */
+isDefaultExported: boolean, name: string, typeParameters: ApiTypeParameter[] | undefined, extendsClause: string | undefined, membersText: string): string;
+export declare function printTypeParameters(typeParameters: ApiTypeParameter[] | undefined): string;
+export declare function printInterface(
+/**
+ * For consistency and to simplify the docs messaging, everything that appears
+ * in our .d.ts files is exported - non-public things don't appear in the .d.ts
+ * files.
+ */
+isDefaultExported: boolean, name: string, typeParameters: ApiTypeParameter[] | undefined, extendsClause: string[] | undefined, membersText: string): string;
+export declare function printMethod(isProtected: boolean, isAbstract: boolean, isStatic: boolean, isOptional: boolean, name: string, typeParameters: ApiTypeParameter[] | undefined, parameters: ApiParameter[] | undefined, returnType: string | undefined): string;
+export declare function printFunction(isDefaultExported: boolean, name: string, typeParameters: ApiTypeParameter[] | undefined, parameters: ApiParameter[] | undefined, returnType: string): string;
+export declare function printSignature(functionLike: Pick<ApiFunctionLike, "parameters" | "return" | "typeParameters">): string;
+export declare function printProperty(isProtected: boolean, isAbstract: boolean, isStatic: boolean, isReadOnly: boolean, isAccessor: boolean, isOptional: boolean, name: string, type: string): string;
+export declare function printGetterSetter(isProtected: boolean, isAbstract: boolean, isStatic: boolean, name: string, getterType: string, setterType: string | undefined): string;
+export declare function printVariable(isDefaultExported: boolean, name: string, type: string): string;
+export declare function printTypeAlias(name: string, typeParameters: ApiTypeParameter[] | undefined, superTypes: string[] | undefined, type: string | undefined): string;

package/dist/utils/print.d.ts

@@ -1,5 +1,4 @@
 import { default as ts } from 'typescript';
-export declare function printNode(node: ts.Node): string;
 /**
  * For usage in error messages. Print original node text if available. Otherwise,
  * print the AST.

package/package.json

@@ -1,23 +1,34 @@
 {
   "name": "@arcgis/api-extractor",
-  "version": "5.0.0-next.8",
+  "version": "5.0.0-next.80",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js",
+    "./diff": "./dist/diff/index.js",
+    "./diffTypes": "./dist/diffTypes/index.js",
+    "./uiUtils": "./dist/uiUtils/index.js",
+    "./extractor/config": {
+      "types": "./dist/extractor/config.d.ts"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist/"
   ],
+  "bin": "./dist/cli.js",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@arcgis/components-build-utils": "5.0.0-next.8",
-    "@arcgis/toolkit": "5.0.0-next.8",
+    "@arcgis/components-build-utils": "5.0.0-next.80",
+    "@arcgis/toolkit": "5.0.0-next.80",
+    "@commander-js/extra-typings": "^14.0.0",
     "chalk": "^5.4.1",
-    "tslib": "^2.8.1",
-    "typescript": "~5.8.3"
+    "commander": "^14.0.0",
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "typescript": "~5.9.3"
   }
 }

package/dist/extractor/index.d.ts

@@ -1,46 +0,0 @@
-import { ApiClassMethod, ApiCustomElementDeclaration, ApiCustomElementField, ApiDeclaration, ApiEvent, ApiExport, ApiJson, ApiModule } from '../apiJson';
-import { default as ts } from 'typescript';
-import { CopyPropertyDoc, CopyMethodDoc, CopyEventDoc } from '../types';
-export type ApiExtractorOptions = {
-    /**
-     * Whether to extract full API information, with type-checking. This should be
-     * the case during build or when running under Storybook. Otherwise, the dev
-     * server should keep API extraction to bare minimum to reduce needless
-     * overhead. Only the information necessary for the dev server is extracted.
-     */
-    isFullApiExtraction: boolean;
-    cwd: string;
-};
-/**
- * This is a base abstract class. It should be subclassed to implement the
- * specific extraction logic.
- */
-export declare abstract class ApiExtractor {
-    options: ApiExtractorOptions;
-    constructor(options: ApiExtractorOptions);
-    protected file: ts.SourceFile;
-    protected apiModule: ApiModule;
-    /** Given an array of TypeScript source files, generate an api.json file */
-    extract(files: readonly ts.SourceFile[]): ApiJson;
-    protected extractModules(files: readonly ts.SourceFile[]): ApiModule[];
-    protected extractModule(module: ts.SourceFile): ApiModule;
-    /**
-     * For a given module, extract all public declarations.
-     */
-    protected extractDeclarations(module: ts.SourceFile): ApiDeclaration[];
-    /**
-     * For each statement in a module, extract a declaration if it is a public API
-     */
-    protected abstract extractDeclaration(statement: ts.Statement): ApiDeclaration | undefined;
-    /**
-     * Infer ApiModule.exports based on ApiModule.declarations.
-     */
-    protected inferExports(declarations: ApiDeclaration[]): ApiExport[];
-    /**
-     * Infer ApiExport based on ApiDeclaration
-     */
-    protected abstract inferExport(declaration: ApiDeclaration): ApiExport | undefined;
-    copyDoc(errorReportingNode: ts.Node, copyDocDefinition: CopyPropertyDoc | undefined, property: ApiCustomElementField, component: ApiCustomElementDeclaration): void;
-    copyDoc(errorReportingNode: ts.Node, copyDocDefinition: CopyMethodDoc | undefined, method: ApiClassMethod, component: ApiCustomElementDeclaration): void;
-    copyDoc(errorReportingNode: ts.Node, copyDocDefinition: CopyEventDoc | undefined, event: ApiEvent, component: ApiCustomElementDeclaration): void;
-}

package/dist/utils/docHelpers.d.ts

@@ -1,9 +0,0 @@
-import { default as ts } from 'typescript';
-import { ApiCustomElementField, ApiCustomElementDeclaration, ApiEvent, ApiDocsTag, ApiCustomElementMember } from '../apiJson';
-export declare function symbolToDocs(checker: ts.TypeChecker, symbol: ts.Signature | ts.Symbol): {
-    description: ApiCustomElementField["description"];
-    docsTags: ApiDocsTag[];
-};
-export declare const internalJsDocTag = "internal";
-export declare function apiMemberToSynthesizedComments(apiMember: ApiCustomElementDeclaration | ApiCustomElementMember | ApiEvent): ts.SynthesizedComment[];
-export declare function setApiDocFromJsDoc(node: ts.PropertyName, checker: ts.TypeChecker, api: Partial<Pick<ApiCustomElementDeclaration, "cssParts" | "cssProperties" | "cssStates" | "slots"> & Pick<ApiCustomElementField, "default" | "deprecated" | "description" | "docsTags" | "privacy" | "readonly">>, docs?: ReturnType<typeof symbolToDocs>): void;