@arcgis/api-extractor 4.32.0-next.11

package/README.md

@@ -0,0 +1,21 @@
+# ArcGIS Maps SDK for JavaScript - API Extractor
+
+**No Esri Technical Support included.**
+
+Package that is part of the [ArcGIS Maps SDK for JavaScript](https://developers.arcgis.com/javascript).
+
+It is not intended to be used directly, but rather used as a dependency by other packages in the SDK.
+
+## License
+
+COPYRIGHT © 2024 Esri
+
+All rights reserved under the copyright laws of the United States and applicable international laws, treaties, and conventions.
+
+This material is licensed for use under the Esri Master License Agreement (MLA), and is bound by the terms of that agreement. You may redistribute and use this code without modification, provided you adhere to the terms of the MLA and include this copyright notice.
+
+See use restrictions at <http://www.esri.com/legal/pdfs/mla_e204_e300/english>
+
+For additional information, contact: Environmental Systems Research Institute, Inc. Attn: Contracts and Legal Services Department 380 New York Street Redlands, California, USA 92373 USA
+
+email: contracts@esri.com

package/dist/apiJson.d.ts

@@ -0,0 +1,1042 @@
+/**
+ * The top-level type of an `api.json` file.
+ *
+ * `api.json` is a superset of custom-elements-manifest.
+ *
+ * @see https://custom-elements-manifest.open-wc.org/analyzer/getting-started/
+ */
+export type ApiJson = {
+    /**
+     * The timestamp at which the metadata was generated, in the format
+     * `YYYY-MM-DDThh:mm:ss`.
+     *
+     * @example "2000-00-00T00:00:00"
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    timestamp: string;
+    /**
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    compiler: {
+        /**
+         * The name of the compiler that generated the metadata.
+         *
+         * @example "@arcgis/api-extractor"
+         */
+        name: string;
+        /**
+         * The version of the compiler that generated the metadata.
+         *
+         * @example "4.32.0"
+         */
+        version: string;
+        /**
+         * The version of TypeScript that was used to generate the metadata.
+         *
+         * @example "5.4.5"
+         */
+        typescriptVersion: string;
+    };
+    /**
+     * The version of the schema used in this file.
+     *
+     * @example "1.0.0"
+     */
+    schemaVersion: string;
+    /**
+     * The Markdown to use for the main readme of this package.
+     *
+     * This can be used to override the readme used by Github or npm if that file
+     * contains information irrelevant to custom element catalogs and
+     * documentation viewers.
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    readme?: string;
+    /**
+     * An array of the modules this package contains.
+     *
+     * The modules should be public entrypoints that other packages may import
+     * from.
+     */
+    modules: ApiModule[];
+    /**
+     * Whether the package is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    deprecated?: boolean | string;
+};
+export type ApiModule = ApiJavaScriptModule;
+export type ApiJavaScriptModule = {
+    kind: "javascript-module";
+    /**
+     * Path to the javascript file needed to be imported.
+     *
+     * @example "src/components/property-types/property-types.tsx"
+     */
+    path: string;
+    /**
+     * A markdown summary suitable for display in a listing.
+     */
+    summary?: string;
+    /**
+     * A markdown description of the module.
+     */
+    description?: string;
+    /**
+     * The declarations of a module.
+     *
+     * For documentation purposes, all declarations that are reachable from
+     * exports should be described here. Ie, functions and objects that may be
+     * properties of exported objects, or passed as arguments to functions.
+     */
+    declarations: ApiDeclaration[];
+    /**
+     * The exports of a module. This includes JavaScript exports and
+     * custom element definitions.
+     */
+    exports?: ApiExport[];
+    /**
+     * Whether the module is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     */
+    deprecated?: boolean | string;
+};
+export type ApiExport = ApiCustomElementExport | ApiJavaScriptExport;
+/**
+ * @remarks
+ * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+ * with custom-elements-manifest.
+ */
+export type ApiJavaScriptExport = {
+    kind: "js";
+    /**
+     * The name of the exported symbol.
+     *
+     * JavaScript has a number of ways to export objects which determine the
+     * correct name to use.
+     *
+     * - Default exports must use the name "default".
+     * - Named exports use the name that is exported. If the export is renamed
+     *   with the "as" clause, use the exported name.
+     * - Aggregating exports (`* from`) should use the name `*`
+     */
+    name: string;
+    /**
+     * A reference to the exported declaration.
+     *
+     * In the case of aggregating exports, the reference's `module` field must be
+     * defined and the `name` field must be `"*"`.
+     */
+    declaration: ApiReference;
+    /**
+     * Whether the export is deprecated. For example, the name of the export was changed.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     */
+    deprecated?: boolean | string;
+};
+/**
+ * A global custom element definition, ie the result of a
+ * `customElements.define()` call.
+ *
+ * This is represented as an export because a definition makes the element
+ * available outside of the module it's defined it.
+ */
+export type ApiCustomElementExport = {
+    kind: "custom-element-definition";
+    /**
+     * The tag name of the custom element.
+     *
+     * @example "arcgis-counter"
+     */
+    name: string;
+    /**
+     * A reference to the class or other declaration that implements the
+     * custom element.
+     */
+    declaration: ApiReference;
+    /**
+     * Whether the custom-element export is deprecated.
+     * For example, a future version will not register the custom element in this file.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     */
+    deprecated?: boolean | string;
+};
+export type ApiDeclaration = ApiClassDeclaration | ApiCustomElementDeclaration | ApiCustomElementMixinDeclaration | ApiFunctionDeclaration | ApiMixinDeclaration | ApiVariableDeclaration;
+/**
+ * A reference to an export of a module.
+ *
+ * All references are required to be publicly accessible, so the canonical
+ * representation of a reference is the export it's available from.
+ *
+ * `package` should generally refer to an npm package name. If `package` is
+ * undefined then the reference is local to this package. If `module` is
+ * undefined the reference is local to the containing module.
+ *
+ * References to global symbols like `Array`, `HTMLElement`, or `Event` should
+ * use a `package` name of `"global:"`.
+ */
+export type ApiReference = {
+    /**
+     * @example "AreaMeasurementAnalysis"
+     */
+    name: string;
+    /**
+     * @example "@arcgis/core"
+     */
+    package?: string;
+    /**
+     * @example "interfaces.d.ts"
+     */
+    module?: string;
+};
+/**
+ * A reference to the source of a declaration or member.
+ *
+ * @remarks
+ * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+ * with custom-elements-manifest.
+ */
+export type ApiSourceReference = {
+    /**
+     * An absolute URL to the source (ie. a GitHub URL).
+     */
+    href: string;
+};
+/**
+ * A description of a custom element class.
+ *
+ * Custom elements are JavaScript classes, so this extends from
+ * `ClassDeclaration` and adds custom-element-specific features like attributes,
+ * events, and slots.
+ *
+ * Note that `tagName` in this interface is optional. Tag names are not
+ * necessarily part of a custom element class, but belong to the definition
+ * (often called the "registration") or the `customElements.define()` call.
+ *
+ * Because classes and tag names can only be registered once, there's a
+ * one-to-one relationship between classes and tag names. For ease of use, we
+ * allow the tag name here.
+ *
+ * Some packages define and register custom elements in separate modules. In
+ * these cases one `Module` should contain the `CustomElement` without a
+ * tagName, and another `Module` should contain the `CustomElementExport`.
+ */
+export type ApiCustomElementDeclaration = ApiClassDeclaration & {
+    /**
+     * An optional tag name that should be specified if this is a
+     * self-registering element.
+     *
+     * Self-registering elements must also include a CustomElementExport in the
+     * module's exports.
+     *
+     * @example "arcgis-counter"
+     */
+    tagName: string;
+    members: ApiCustomElementMember[];
+    superclass: ApiReference;
+    /**
+     * The attributes that this element is known to understand.
+     *
+     * For most use cases, the "members" array includes properties will all the
+     * information included in the "attributes" array. Thus directly accessing
+     * "attributes" is not necessary.
+     */
+    attributes?: ApiAttribute[];
+    /**
+     * The events that this element fires.
+     */
+    events?: ApiEvent[];
+    /**
+     * The shadow dom content slots that this element accepts.
+     */
+    slots?: ApiSlot[];
+    cssParts?: ApiCssPart[];
+    cssProperties?: ApiCssCustomProperty[];
+    cssStates?: ApiCssCustomState[];
+    demos?: ApiDemo[];
+    /**
+     * Distinguishes a regular JavaScript class from a custom element class
+     */
+    customElement: true;
+    /**
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    docsTags?: ApiDocsTag[];
+    /**
+     * The path from which the component can be imported.
+     *
+     * @example "components/arcgis-area-measurement-2d"
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    importPath: string;
+    /**
+     * @default "shadow"
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    encapsulation?: "none" | "shadow";
+    /**
+     * @example "HTMLArcgisCounterElement"
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    typeName: string;
+};
+/**
+ * A descriptor for a single JSDoc tag found in a block comment.
+ *
+ * @remarks
+ * Some tags have dedicated fields. Those will be excluded from array of
+ * "docsTags".
+ */
+export type ApiDocsTag = {
+    /**
+     * The tag name (immediately following the '@').
+     *
+     * @example "since"
+     */
+    name: string;
+    /**
+     * The description that immediately follows the tag name.
+     *
+     * @example "4.31"
+     */
+    text?: string;
+};
+/**
+ * For most use cases, the "members" array includes properties will all the
+ * information included in the "attributes" array. Thus directly accessing
+ * "attributes" is not necessary.
+ */
+export type ApiAttribute = {
+    /**
+     * @example "initial-count"
+     */
+    name: string;
+    /**
+     * A markdown summary suitable for display in a listing.
+     */
+    summary?: string;
+    /**
+     * A markdown description.
+     */
+    description?: string;
+    inheritedFrom?: ApiReference;
+    /**
+     * The type that the attribute will be serialized/deserialized as.
+     */
+    type: ApiType;
+    /**
+     * The default value of the attribute, if any.
+     *
+     * As attributes are always strings, this is the actual value, not a human
+     * readable description.
+     *
+     * @example "10"
+     */
+    default?: string;
+    /**
+     * The name of the field this attribute is associated with.
+     *
+     * @example "initialCount"
+     */
+    fieldName?: string;
+    /**
+     * Whether the attribute is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     */
+    deprecated?: boolean | string;
+};
+export type ApiEvent = {
+    /**
+     * @example "arcgisClick"
+     */
+    name: string;
+    /**
+     * A markdown summary suitable for display in a listing.
+     */
+    summary?: string;
+    /**
+     * A markdown description.
+     */
+    description?: string;
+    /**
+     * The type of the event object that's fired.
+     */
+    type: Omit<ApiType, "values">;
+    inheritedFrom?: ApiReference;
+    /**
+     * Whether the event is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     */
+    deprecated?: boolean | string;
+    /**
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    docsTags?: ApiDocsTag[];
+    /**
+     * @default true
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    bubbles?: boolean;
+    /**
+     * @default true
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    cancelable?: boolean;
+    /**
+     * @default true
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    composed?: boolean;
+    /**
+     * @default "public"
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Present for completeness.
+     */
+    privacy?: ApiPrivacy;
+};
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot
+ */
+export type ApiSlot = {
+    /**
+     * The slot name, or the empty string for an unnamed slot.
+     *
+     * @example "header"
+     */
+    name: string;
+    /**
+     * A markdown summary suitable for display in a listing.
+     */
+    summary?: string;
+    /**
+     * A markdown description.
+     */
+    description?: string;
+    /**
+     * Whether the slot is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    deprecated?: boolean | string;
+};
+/**
+ * The description of exposed CSS Parts
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_shadow_parts
+ */
+export type ApiCssPart = {
+    /**
+     * @example "tab"
+     */
+    name: string;
+    /**
+     * A markdown summary suitable for display in a listing.
+     */
+    summary?: string;
+    /**
+     * A markdown description.
+     */
+    description?: string;
+    /**
+     * Whether the CSS shadow part is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    deprecated?: boolean | string;
+};
+/**
+ * The description of a CSS Custom State.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomStateSet
+ */
+export type ApiCssCustomState = {
+    /**
+     * The name of the state. Note: Unlike CSS custom properties, custom states
+     * do not have a leading `--`.
+     *
+     * @example "active"
+     */
+    name: string;
+    /**
+     * A markdown summary suitable for display in a listing.
+     */
+    summary?: string;
+    /**
+     * A markdown description.
+     */
+    description?: string;
+    /**
+     * Whether the CSS custom state is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    deprecated?: boolean | string;
+};
+export type ApiCssCustomProperty = {
+    /**
+     * The name of the property, including leading `--`.
+     *
+     * @example "--calcite-text-color"
+     */
+    name: string;
+    /**
+     * The expected syntax of the defined property. Defaults to "*".
+     *
+     * The syntax must be a valid CSS
+     * [syntax string](https://developer.mozilla.org/en-US/docs/Web/CSS/@property/syntax)
+     * as defined in the CSS Properties and Values API.
+     *
+     * Examples:
+     *
+     * "<color>": accepts a color
+     * "<length> | <percentage>": accepts lengths or percentages but not calc expressions with a combination of the two
+     * "small | medium | large": accepts one of these values set as custom indents.
+     * "*": any valid token
+     */
+    syntax?: string;
+    default?: string;
+    /**
+     * A markdown summary suitable for display in a listing.
+     */
+    summary?: string;
+    /**
+     * A markdown description.
+     */
+    description?: string;
+    /**
+     * Whether the CSS custom property is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    deprecated?: boolean | string;
+};
+export type ApiType = {
+    /**
+     * The full string representation of the type, in whatever type syntax is
+     * used, such as JSDoc, Closure, or TypeScript.
+     *
+     * This represents a 'resolved' type, where e.g. imported types have been
+     * resolved and inlined.
+     *
+     * @example Array<"active" | "inactive">
+     */
+    text: string;
+    /**
+     * An array of references to the types in the type string.
+     *
+     * These references have optional indices into the type string so that tools
+     * can understand the references in the type string independently of the type
+     * system and syntax. For example, a documentation viewer could display the
+     * type `Array<FooElement | BarElement>` with cross-references to `FooElement`
+     * and `BarElement` without understanding arrays, generics, or union types.
+     */
+    references?: ApiTypeReference[];
+    /**
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    source?: ApiSourceReference;
+    /**
+     * An enum of possible values for this type.
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    values?: ApiValue[];
+};
+export type ApiValue = {
+    /**
+     * @example "string"
+     */
+    type: string;
+    /**
+     * @example "active"
+     */
+    value?: string;
+};
+/**
+ * A reference that is associated with a type string and optionally a range
+ * within the string.
+ *
+ * Start and end must both be present or not present. If they're present, they
+ * are indices into the associated type string. If they are missing, the entire
+ * type string is the symbol referenced and the name should match the type
+ * string.
+ */
+export type ApiTypeReference = ApiReference & {
+    start?: number;
+    end?: number;
+};
+/**
+ * The common interface of classes and mixins.
+ */
+export type ApiClassDeclaration = {
+    kind: "class";
+    /**
+     * @example "ArcgisCounter"
+     */
+    name: string;
+    /**
+     * A markdown summary suitable for display in a listing.
+     */
+    summary?: string;
+    /**
+     * A markdown description of the class.
+     */
+    description?: string;
+    /**
+     * The superclass of this class.
+     *
+     * If this class is defined with mixin applications, the prototype chain
+     * includes the mixin applications and the true superclass is computed
+     * from them.
+     */
+    superclass?: ApiReference;
+    /**
+     * Any class mixins applied in the extends clause of this class.
+     *
+     * If mixins are applied in the class definition, then the true superclass
+     * of this class is the result of applying mixins in order to the superclass.
+     *
+     * Mixins must be listed in order of their application to the superclass or
+     * previous mixin application. This means that the innermost mixin is listed
+     * first. This may read backwards from the common order in JavaScript, but
+     * matches the order of language used to describe mixin application, like
+     * "S with A, B".
+     *
+     * @example
+     *
+     * ```javascript
+     * class T extends B(A(S)) {}
+     * ```
+     *
+     * is described by:
+     * ```json
+     * {
+     *   "kind": "class",
+     *   "superclass": {
+     *     "name": "S"
+     *   },
+     *   "mixins": [
+     *     {
+     *       "name": "A"
+     *     },
+     *     {
+     *       "name": "B"
+     *     },
+     *   ]
+     * }
+     * ```
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    mixins?: ApiReference[];
+    members?: ApiClassMember[];
+    /**
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    source?: ApiSourceReference;
+    /**
+     * Whether the class or mixin is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     */
+    deprecated?: boolean | string;
+    /**
+     * @default "public"
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Present for completeness.
+     */
+    privacy?: ApiPrivacy;
+};
+export type ApiClassMember = ApiClassField | ApiClassMethod;
+export type ApiCustomElementMember = ApiClassMethod | ApiCustomElementField;
+/**
+ * The common interface of variables, class fields, and function
+ * parameters.
+ */
+export type ApiPropertyLike = {
+    /**
+     * @example "initialCount"
+     */
+    name: string;
+    /**
+     * A markdown summary suitable for display in a listing.
+     */
+    summary?: string;
+    /**
+     * A markdown description of the field.
+     */
+    description?: string;
+    type: ApiType;
+    /**
+     * @example 10
+     */
+    default?: string;
+    /**
+     * Whether the property is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     */
+    deprecated?: boolean | string;
+    /**
+     * Whether the property is read-only.
+     *
+     * @default false
+     */
+    readonly?: boolean;
+};
+export type ApiClassField = ApiPropertyLike & {
+    kind: "field";
+    /**
+     * @default false
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     *
+     * All static members are excluded from the api.json.
+     */
+    static?: boolean;
+    /**
+     * @default "public"
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     *
+     * All private and protected fields are excluded from the api.json.
+     */
+    privacy?: ApiPrivacy;
+    inheritedFrom?: ApiReference;
+    /**
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    source?: ApiSourceReference;
+};
+/**
+ * Additional metadata for fields on custom elements.
+ */
+export type ApiCustomElementField = ApiClassField & {
+    /**
+     * The corresponding attribute name if there is one.
+     *
+     * If this property is defined, the attribute must be listed in the classes'
+     * `attributes` array.
+     *
+     * @example "initial-counter"
+     */
+    attribute?: string;
+    /**
+     * If the property reflects to an attribute.
+     *
+     * If this is true, the `attribute` property must be defined.
+     *
+     * @default false
+     */
+    reflects?: boolean;
+    /**
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    docsTags?: ApiDocsTag[];
+    /**
+     * Whether field has both getter and setter, and their types are different.
+     * The actual getter type is not included in the api.json at the moment, but
+     * can be added if that information is needed.
+     *
+     * @default false
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    getterTypeDiffers?: boolean;
+    /**
+     * For some properties, we show them as read-only in the docs and in the
+     * typings but don't actually enforce read-only at runtime.
+     *
+     * Such properties are represented in the manifest with both `readonly` and
+     * `docsOnlyReadonly` set to true.
+     *
+     * Runtime read-only properties are represented with only `readonly` true.
+     *
+     * @default false
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    docsOnlyReadonly?: boolean;
+};
+export type ApiClassMethod = ApiFunctionLike & {
+    kind: "method";
+    /**
+     * @default false
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     *
+     * All static members are excluded from the api.json.
+     */
+    static?: boolean;
+    /**
+     * @default "public"
+     *
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     *
+     * All private and protected fields are excluded from the api.json.
+     */
+    privacy?: ApiPrivacy;
+    inheritedFrom?: ApiReference;
+    /**
+     * @remarks
+     * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+     * with custom-elements-manifest.
+     */
+    source?: ApiSourceReference;
+    /**
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    docsTags?: ApiDocsTag[];
+    /**
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    signature: string;
+    /**
+     * @default false
+     *
+     * @remarks
+     * Not present in vanilla custom-elements-manifest.
+     */
+    async?: boolean;
+};
+/**
+ * A description of a class mixin.
+ *
+ * Mixins are functions which generate a new subclass of a given superclass.
+ * This interfaces describes the class and custom element features that
+ * are added by the mixin. As such, it extends the CustomElement interface and
+ * ClassLike interface.
+ *
+ * Since mixins are functions, it also extends the FunctionLike interface. This
+ * means a mixin is callable, and has parameters and a return type.
+ *
+ * The return type is often hard or impossible to accurately describe in type
+ * systems like TypeScript. It requires generics and an `extends` operator
+ * that TypeScript lacks. Therefore it's recommended that the return type is
+ * left empty. The most common form of a mixin function takes a single
+ * argument, so consumers of this interface should assume that the return type
+ * is the single argument subclassed by this declaration.
+ *
+ * A mixin should not have a superclass. If a mixins composes other mixins,
+ * they should be listed in the `mixins` field.
+ *
+ * See more information on the class mixin pattern in JavaScript:
+ * https://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/
+ *
+ * @example
+ *
+ * This JavaScript mixin declaration:
+ * ```javascript
+ * const MyMixin = (base) => class extends base {
+ *   foo() { ... }
+ * }
+ * ```
+ *
+ * Is described by this JSON:
+ * ```json
+ * {
+ *   "kind": "mixin",
+ *   "name": "MyMixin",
+ *   "parameters": [
+ *     {
+ *       "name": "base",
+ *     }
+ *   ],
+ *   "members": [
+ *     {
+ *       "kind": "method",
+ *       "name": "foo",
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * @remarks
+ * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+ * with custom-elements-manifest.
+ */
+export type ApiMixinDeclaration = ApiClassDeclaration & ApiFunctionLike & {
+    kind: "mixin";
+};
+/**
+ * A class mixin that also adds custom element related properties.
+ *
+ * @remarks
+ * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+ * with custom-elements-manifest.
+ */
+export type ApiCustomElementMixinDeclaration = ApiCustomElementDeclaration & ApiMixinDeclaration;
+/**
+ * @remarks
+ * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+ * with custom-elements-manifest.
+ */
+export type ApiVariableDeclaration = ApiPropertyLike & {
+    kind: "variable";
+    source?: ApiSourceReference;
+};
+/**
+ * @remarks
+ * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+ * with custom-elements-manifest.
+ */
+export type ApiFunctionDeclaration = ApiFunctionLike & {
+    kind: "function";
+    source?: ApiSourceReference;
+};
+export type ApiParameter = ApiPropertyLike & {
+    /**
+     * Whether the parameter is optional.
+     *
+     * @default false
+     */
+    optional?: boolean;
+    /**
+     * @default false
+     *
+     * Whether the parameter is a rest parameter. Only the last parameter may be a rest parameter.
+     * Undefined implies single parameter.
+     */
+    rest?: boolean;
+};
+export type ApiFunctionLike = {
+    /**
+     * @example "increment"
+     */
+    name: string;
+    /**
+     * A markdown summary suitable for display in a listing.
+     */
+    summary?: string;
+    /**
+     * A markdown description.
+     */
+    description?: string;
+    /**
+     * Whether the function is deprecated.
+     * If the value is a string, it's the reason for the deprecation.
+     *
+     * @default false
+     */
+    deprecated?: boolean | string;
+    /**
+     * @default []
+     */
+    parameters?: ApiParameter[];
+    return?: {
+        type?: ApiType;
+        /**
+         * A markdown summary suitable for display in a listing.
+         */
+        summary?: string;
+        /**
+         * A markdown description.
+         */
+        description?: string;
+    };
+};
+/**
+ * @remarks
+ * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+ * with custom-elements-manifest.
+ */
+export type ApiPrivacy = "private" | "protected" | "public";
+/**
+ * @remarks
+ * Not used by `@arcgis/api-extractor`. Preserved in typings for compatibility
+ * with custom-elements-manifest.
+ */
+export type ApiDemo = {
+    /**
+     * A markdown description of the demo.
+     */
+    description: string;
+    /**
+     * Relative URL of the demo if it's published with the package. Absolute URL
+     * if it's hosted.
+     */
+    url: string;
+    source?: ApiSourceReference;
+};

package/dist/ensureValidType.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/extractor/index.d.ts

@@ -0,0 +1,42 @@
+import type { ApiDeclaration, ApiExport, ApiJson, ApiModule } from "../apiJson";
+import ts from "typescript";
+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;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { ApiExtractor, type ApiExtractorOptions } from "./extractor";
+export * from "./apiJson";
+export { hasIgnoredModifier, setDefaultFromInitializer, getMemberName } from "./utils/astHelpers";
+export { isApiMethod, isApiProperty, globalPackageIdentifier } from "./utils/apiHelpers";

package/dist/index.js

@@ -0,0 +1,141 @@
+// package.json
+var name = "@arcgis/api-extractor";
+var version = "4.32.0-next.11";
+
+// src/extractor/index.ts
+import ts from "typescript";
+
+// src/utils/apiHelpers.ts
+var isApiMethod = (member) => member.kind === "method";
+var isApiProperty = (member) => member.kind === "field";
+function naturalSortModules(left, right) {
+  const leftSplit = left.path.split("/");
+  const leftName = leftSplit.pop();
+  const leftDirectories = leftSplit.join("/");
+  const rightSplit = right.path.split("/");
+  const rightName = rightSplit.pop();
+  const rightDirectories = rightSplit.join("/");
+  if (leftDirectories === rightDirectories) {
+    return leftName < rightName ? -1 : 1;
+  } else if (leftDirectories.startsWith(rightDirectories)) {
+    return 1;
+  } else if (rightDirectories.startsWith(leftDirectories)) {
+    return -1;
+  } else {
+    return leftDirectories < rightDirectories ? -1 : 1;
+  }
+}
+var globalPackageIdentifier = "global:";
+
+// src/extractor/index.ts
+import { path } from "@arcgis/components-build-utils";
+var ApiExtractor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /** Given an array of TypeScript source files, generate an api.json file */
+  extract(files) {
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString().split(".")[0],
+      compiler: {
+        name,
+        version,
+        typescriptVersion: ts.version
+      },
+      schemaVersion: "1.0.0",
+      modules: this.extractModules(files)
+    };
+  }
+  extractModules(files) {
+    const modules = [];
+    for (const file of files) {
+      this.file = file;
+      modules.push(this.extractModule(file));
+    }
+    if (this.options.isFullApiExtraction) {
+      modules.sort(naturalSortModules);
+    }
+    return modules;
+  }
+  extractModule(module) {
+    const apiModule = {
+      kind: "javascript-module",
+      path: path.relative(this.options.cwd, module.fileName),
+      declarations: void 0,
+      exports: void 0
+    };
+    this.apiModule = apiModule;
+    const declarations = this.extractDeclarations(module);
+    apiModule.declarations = declarations;
+    if (this.options.isFullApiExtraction) {
+      const exports = this.inferExports(declarations);
+      if (exports.length > 0) {
+        apiModule.exports = exports;
+      }
+    }
+    return apiModule;
+  }
+  /**
+   * For a given module, extract all public declarations.
+   */
+  extractDeclarations(module) {
+    const declarations = [];
+    for (const statement of module.statements) {
+      const declaration = this.extractDeclaration(statement);
+      if (declaration !== void 0) {
+        declarations.push(declaration);
+      }
+    }
+    return declarations;
+  }
+  /**
+   * Infer ApiModule.exports based on ApiModule.declarations.
+   */
+  inferExports(declarations) {
+    const exports = [];
+    for (const declaration of declarations) {
+      const exported = this.inferExport(declaration);
+      if (exported !== void 0) {
+        exports.push(exported);
+      }
+    }
+    return exports;
+  }
+};
+
+// src/utils/astHelpers.ts
+import ts2 from "typescript";
+var hasIgnoredModifier = (member) => member.modifiers?.some?.(
+  (modifier) => modifier.kind === ts2.SyntaxKind.StaticKeyword || modifier.kind === ts2.SyntaxKind.PrivateKeyword || modifier.kind === ts2.SyntaxKind.ProtectedKeyword
+) ?? false;
+function setDefaultFromInitializer(node, property, sourceFile) {
+  if (!property.default && "initializer" in node && node.initializer) {
+    const unpacked = unpackInitializer(node.initializer);
+    if (isDefaultValueDocumentationEligible(unpacked)) {
+      property.default = unpacked.getText(sourceFile);
+    }
+  }
+}
+var isDefaultValueDocumentationEligible = (initializer) => ts2.isLiteralExpression(initializer) || initializer.kind === ts2.SyntaxKind.TrueKeyword || initializer.kind === ts2.SyntaxKind.FalseKeyword || ts2.isPrefixUnaryExpression(initializer) && ts2.isLiteralExpression(initializer.operand);
+function unpackInitializer(expression) {
+  if (ts2.isSatisfiesExpression(expression) || ts2.isParenthesizedExpression(expression)) {
+    return unpackInitializer(expression.expression);
+  } else {
+    return expression;
+  }
+}
+function getMemberName(name2) {
+  if (ts2.isIdentifier(name2) || ts2.isStringLiteralLike(name2)) {
+    return name2.text;
+  }
+  return void 0;
+}
+export {
+  ApiExtractor,
+  getMemberName,
+  globalPackageIdentifier,
+  hasIgnoredModifier,
+  isApiMethod,
+  isApiProperty,
+  setDefaultFromInitializer
+};

package/dist/utils/apiHelpers.d.ts

@@ -0,0 +1,22 @@
+import type { ApiClassMember, ApiClassMethod, ApiCustomElementField, ApiModule } from "../apiJson";
+export declare const isApiMethod: (member: ApiClassMember) => member is ApiClassMethod;
+export declare const isApiProperty: (member: ApiClassMember) => member is ApiCustomElementField;
+/**
+ * Being a bit smarter than simply sorting paths alphabetically. The goal
+ * is that nested components appear after their parent component. Otherwise,
+ * simple alphabetical.
+ *
+ * @example
+ * ```ts
+ * [
+ *  "src/components/z/z.js",
+ *  "src/components/z/components/sub-a.js",
+ *  "src/components/z/components/sub-z.js",
+ * ]
+ * ```
+ */
+export declare function naturalSortModules(left: ApiModule, right: ApiModule): number;
+/**
+ * This is not made up by us - defined in the custom-elements-manifest spec
+ */
+export declare const globalPackageIdentifier = "global:";

package/dist/utils/astHelpers.d.ts

@@ -0,0 +1,9 @@
+import ts from "typescript";
+import type { ApiPropertyLike } from "../apiJson";
+export declare const hasIgnoredModifier: (member: ts.ClassElement) => boolean;
+export declare function setDefaultFromInitializer(node: ts.AccessorDeclaration | ts.PropertyDeclaration, property: ApiPropertyLike, sourceFile: ts.SourceFile): void;
+/**
+ * Convert property name node into a string. Converts Identifier and
+ * StringLiteralLike nodes. The rest return undefined.
+ */
+export declare function getMemberName(name: ts.PropertyName): string | undefined;

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@arcgis/api-extractor",
+  "version": "4.32.0-next.11",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/"
+  ],
+  "license": "SEE LICENSE IN LICENSE.md",
+  "dependencies": {
+    "@arcgis/components-build-utils": "4.32.0-next.11",
+    "@arcgis/components-utils": "4.32.0-next.11",
+    "tslib": "^2.7.0",
+    "typescript": "~5.6.3"
+  }
+}