# https://jsr.io/@scope/a/meta.json
{"versions": { "1.0.0": {} } }

# https://jsr.io/@scope/a/1.0.0_meta.json
{ "exports": { ".": "./mod.ts" } }

# https://jsr.io/@scope/a/1.0.0/mod.ts
const getEntity = Symbol();

export class PrivateMethodOverloadable {
  private constructor();
  private constructor() {
  }

  private [getEntity](): Promise<string>;
  private async [getEntity]() {
  }

  private method(): string {

  }

  private methodWithOverload(): string;
  private methodWithOverload(): string {

  }

  private [123](): string;
  private [123](): string {

  }

  private [9876n](): string;
  private [9876n](): string {

  }

  private "stringAndIdent"(): string;
  private stringAndIdent(): string {
  }

  private "stringOnly"(): string;
  private "stringOnly"(): string {
  }
}

class Private {}

const symbol1 = Symbol();
export declare class AmbientPrivateMethodOverloadable {
  private constructor(value: string);
  private constructor(private: Private);

  private [symbol1](value: string): Promise<string>;
  private async [symbol1]();

  private method(value: string): string;

  private methodWithOverload(value: string): string;
  private methodWithOverload(): string;

  private [123](value: string): string;
  private [123](): string;

  private [9876n](value: string): string;
  private [9876n](): string;

  private "stringAndIdent"(value: string): string;
  private stringAndIdent(): string;

  private "stringOnly"(value: string): string;
  private "stringOnly"(): string;
}

export declare module Test {
  export class AmbientClassInModule {
    private constructor(value: string);
    private constructor(private: Private);

    private [symbol1](value: string): Promise<string>;
    private async [symbol1]();
  }
}

class Base {}
export class TsPrivateMethodWithOverrideKeyword extends Base {
  private override test(): string {
    return "";
  }
}

# mod.ts
import 'jsr:@scope/a'

# output
{
  "roots": [
    "file:///mod.ts"
  ],
  "modules": [
    {
      "kind": "esm",
      "dependencies": [
        {
          "specifier": "jsr:@scope/a",
          "code": {
            "specifier": "jsr:@scope/a",
            "resolutionMode": "import",
            "span": {
              "start": {
                "line": 0,
                "character": 7
              },
              "end": {
                "line": 0,
                "character": 21
              }
            }
          }
        }
      ],
      "size": 22,
      "mediaType": "TypeScript",
      "specifier": "file:///mod.ts"
    },
    {
      "kind": "esm",
      "size": 1698,
      "mediaType": "TypeScript",
      "specifier": "https://jsr.io/@scope/a/1.0.0/mod.ts"
    }
  ],
  "redirects": {
    "jsr:@scope/a": "https://jsr.io/@scope/a/1.0.0/mod.ts"
  },
  "packages": {
    "@scope/a@*": "@scope/a@1.0.0"
  }
}

Fast check https://jsr.io/@scope/a/1.0.0/mod.ts:
  {}
  export class PrivateMethodOverloadable {
    private constructor(){}
    declare private method: any;
    declare private methodWithOverload: any;
    declare private "stringAndIdent": any;
    declare private "stringOnly": any;
  }
  export declare class AmbientPrivateMethodOverloadable {
    private constructor(value: string);
    private constructor(private: Private);
    private method(value: string): string;
    private methodWithOverload(value: string): string;
    private methodWithOverload(): string;
    private "stringAndIdent"(value: string): string;
    private stringAndIdent(): string;
    private "stringOnly"(value: string): string;
    private "stringOnly"(): string;
  }
  export declare namespace Test {
    export class AmbientClassInModule {
      private constructor(value: string);
      private constructor(private: Private);
    }
  }
  class Base {
  }
  export class TsPrivateMethodWithOverrideKeyword extends Base {
    declare private test: any;
  }
  --- DTS ---
  export declare class PrivateMethodOverloadable {
    private constructor();
    private method: any;
    private methodWithOverload: any;
    private "stringAndIdent": any;
    private "stringOnly": any;
  }
  export declare class AmbientPrivateMethodOverloadable {
    private constructor(value: string);
    private constructor(private: Private);
    private method(value: string): string;
    private methodWithOverload(value: string): string;
    private methodWithOverload(): string;
    private "stringAndIdent"(value: string): string;
    private stringAndIdent(): string;
    private "stringOnly"(value: string): string;
    private "stringOnly"(): string;
  }
  export declare namespace Test {
    export class AmbientClassInModule {
      private constructor(value: string);
      private constructor(private: Private);
    }
  }
  declare class Base {
  }
  export declare class TsPrivateMethodWithOverrideKeyword extends Base {
    private test: any;
  }
