@jsdocs-io/extractor

const InstallPackageError_base: new <A extends Record<string, any> = {}>(
    args: void | { readonly [P in keyof A as P extends '_tag' ? never : P]: A[P] }
) => any;

const PackageDeclarationsError_base: new <A extends Record<string, any> = {}>(
    args: void | { readonly [P in keyof A as P extends '_tag' ? never : P]: A[P] }
) => any;

const PackageJsonError_base: new <A extends Record<string, any> = {}>(
    args: void | { readonly [P in keyof A as P extends '_tag' ? never : P]: A[P] }
) => any;

const PackageManager_base: Context.TagClass<
    PackageManager,
    'PackageManager',
    {
        readonly installPackage: ({
            pkg,
            cwd,
        }: InstallPackageOptions) => Effect.Effect<string[], InstallPackageError>;
    }
>;

const PackageNameError_base: new <A extends Record<string, any> = {}>(
    args: void | { readonly [P in keyof A as P extends '_tag' ? never : P]: A[P] }
) => any;

const PackageTypesError_base: new <A extends Record<string, any> = {}>(
    args: void | { readonly [P in keyof A as P extends '_tag' ? never : P]: A[P] }
) => any;

const ProjectError_base: new <A extends Record<string, any> = {}>(
    args: void | { readonly [P in keyof A as P extends '_tag' ? never : P]: A[P] }
) => any;

const WorkDirError_base: new <A extends Record<string, any> = {}>(
    args: void | { readonly [P in keyof A as P extends '_tag' ? never : P]: A[P] }
) => any;

extractPackageApi: ({
    pkg,
    subpath,
    maxDepth,
    bunPath,
}: ExtractPackageApiOptions) => Promise<PackageApi>;

type AllExtractedDeclaration =
    | ExtractedVariable
    | ExtractedFunction
    | ExtractedClass
    | ExtractedClassConstructor
    | ExtractedClassProperty
    | ExtractedClassMethod
    | ExtractedInterface
    | ExtractedInterfaceProperty
    | ExtractedInterfaceMethod
    | ExtractedInterfaceConstructSignature
    | ExtractedInterfaceCallSignature
    | ExtractedInterfaceIndexSignature
    | ExtractedInterfaceGetAccessor
    | ExtractedInterfaceSetAccessor
    | ExtractedEnum
    | ExtractedEnumMember
    | ExtractedTypeAlias
    | ExtractedNamespace;

type AllExtractedDeclarationKind = AllExtractedDeclaration['kind'];

type ExtractedClass = {
    kind: 'class';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
    constructors: ExtractedClassConstructor[];
    properties: ExtractedClassProperty[];
    methods: ExtractedClassMethod[];
};

type ExtractedClassConstructor = {
    kind: 'class-constructor';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedClassMethod = {
    kind: 'class-method';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedClassProperty = {
    kind: 'class-property';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedDeclaration =
    | ExtractedVariable
    | ExtractedFunction
    | ExtractedClass
    | ExtractedInterface
    | ExtractedEnum
    | ExtractedTypeAlias
    | ExtractedNamespace;

type ExtractedDeclarationKind = ExtractedDeclaration['kind'];

type ExtractedEnum = {
    kind: 'enum';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
    members: ExtractedEnumMember[];
};

type ExtractedEnumMember = {
    kind: 'enum-member';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedFunction = {
    kind: 'function';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedInterface = {
    kind: 'interface';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
    properties: ExtractedInterfaceProperty[];
    methods: ExtractedInterfaceMethod[];
    constructSignatures: ExtractedInterfaceConstructSignature[];
    callSignatures: ExtractedInterfaceCallSignature[];
    indexSignatures: ExtractedInterfaceIndexSignature[];
    getAccessors: ExtractedInterfaceGetAccessor[];
    setAccessors: ExtractedInterfaceSetAccessor[];
};

type ExtractedInterfaceCallSignature = {
    kind: 'interface-call-signature';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedInterfaceConstructSignature = {
    kind: 'interface-construct-signature';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedInterfaceGetAccessor = {
    kind: 'interface-get-accessor';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedInterfaceIndexSignature = {
    kind: 'interface-index-signature';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedInterfaceMethod = {
    kind: 'interface-method';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedInterfaceProperty = {
    kind: 'interface-property';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedInterfaceSetAccessor = {
    kind: 'interface-set-accessor';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedNamespace = {
    kind: 'namespace';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
    declarations: ExtractedDeclaration[];
};

type ExtractedTypeAlias = {
    kind: 'type';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractedVariable = {
    kind: 'variable';
    id: string;
    name: string;
    docs: string[];
    file: string;
    line: number;
    signature: string;
};

type ExtractPackageApiOptions = {
    /**
  Package to extract the API from.

  This can be either a package name (e.g., `foo`) or any other query
  that can be passed to `bun add` (e.g., `foo@1.0.0`).

  @see {@link https://bun.sh/docs/cli/add | Bun docs}
  */
    pkg: string;
    /**
  Specific subpath to consider in a package.

  If a package has multiple entrypoints listed in the `exports` property
  of its `package.json`, use `subpath` to select a specific one by its name
  (e.g., `someFeature`).

  @defaultValue `.` (package root)

  @see {@link https://nodejs.org/api/packages.html#subpath-exports | Node.js docs}
  @see {@link https://github.com/lukeed/resolve.exports | resolve.exports docs}
  */
    subpath?: string;
    /**
  Packages can have deeply nested modules and namespaces.

  Use `maxDepth` to limit the depth of the extraction.
  Declarations nested at levels deeper than this value will be ignored.

  @defaultValue 5
  */
    maxDepth?: number;
    /**
  Absolute path to the `bun` executable.
  Used to locate bun if it's not in `PATH`.

  @defaultValue `bun`
  */
    bunPath?: string;
};

type PackageApi = {
    /** Package name (e.g., `foo`). */
    name: string;
    /** Package version number (e.g., `1.0.0`). */
    version: string;
    /**
  Package subpath selected when extracting the API (e.g., `.`, `someFeature`).

  @see {@link ExtractPackageApiOptions.subpath}
  @see {@link https://nodejs.org/api/packages.html#subpath-exports | Node.js docs}
  */
    subpath: string;
    /**
  Type declarations file, resolved from the selected `subpath`,
  that acts as the entrypoint for the package (e.g., `index.d.ts`).
  */
    types: string;
    /**
  Package description extracted from the `types` file if a
  JSDoc comment with the `@packageDocumentation` tag is found.
  */
    overview: string | undefined;
    /** Declarations exported (or re-exported) by the package. */
    declarations: ExtractedDeclaration[];
    /**
  All packages resolved and installed when installing the package (included).

  @example
  ```ts
  ["foo@1.0.0", "bar@2.0.0", "baz@3.0.0"]
  ```
  */
    packages: string[];
    /** Timestamp of when the package was analyzed. */
    analyzedAt: string;
    /** Package analysis duration in milliseconds. */
    analyzedIn: number;
};