How to use the vscode-debugadapter.TerminatedEvent function in vscode-debugadapter

protected launchRequest(response: DebugProtocol.LaunchResponse, args: DartLaunchRequestArguments): void {
		if (!args || !args.dartPath || (this.requiresProgram && !args.program)) {
			this.sendEvent(new OutputEvent("Unable to restart debugging. Please try ending the debug session and starting again."));
			this.sendEvent(new TerminatedEvent());
			return;
		}

		// Force relative paths to absolute.
		if (args.program && !path.isAbsolute(args.program))
			args.program = path.join(args.cwd, args.program);
		this.shouldKillProcessOnTerminate = true;
		this.cwd = args.cwd;
		this.packageMap = new PackageMap(PackageMap.findPackagesFile(args.program || args.cwd));
		this.debugSdkLibraries = args.debugSdkLibraries;
		this.debugExternalLibraries = args.debugExternalLibraries;
		this.evaluateGettersInDebugViews = args.evaluateGettersInDebugViews;
		this.logFile = args.observatoryLogFile;
		this.maxLogLineLength = args.maxLogLineLength;

		this.sendResponse(response);

private shutdown = async () => {
        logger.verbose('check and shutdown');
        if (this.hasShutdown) {
            return;
        }
        this.hasShutdown = true;
        logger.verbose('shutdown');

        if (!this.terminatedEventSent && !this.restart) {
            // Possible PTVSD died before sending message back.
            try {
                logger.verbose('Sending Terminated Event');
                this.sendMessage(new TerminatedEvent(), this.outputStream);
            } catch (err) {
                const message = `Error in sending Terminated Event: ${err && err.message ? err.message : err.toString()}`;
                const details = [message, err && err.name ? err.name : '', err && err.stack ? err.stack : ''].join(EOL);
                logger.error(`${message}${EOL}${details}`);
            }
            this.terminatedEventSent = true;
        }

        if (!this.disconnectResponseSent && this.restart && this.disconnectRequest) {
            // This is a work around for PTVSD bug, else this entire block is unnecessary.
            try {
                logger.verbose('Sending Disconnect Response');
                this.sendMessage(new Response(this.disconnectRequest, ''), this.outputStream);
            } catch (err) {
                const message = `Error in sending Disconnect Response: ${err && err.message ? err.message : err.toString()}`;
                const details = [message, err && err.name ? err.name : '', err && err.stack ? err.stack : ''].join(EOL);

this.runtime.on('end', () => {
            this.sendEvent(new TerminatedEvent());
        });
    }

private handleSessionTerminated(message: DebuggerMessage): void {
    if (message.sobject.Description) {
      this.errorToDebugConsole(message.sobject.Description);
      this.sendEvent(
        new Event(SHOW_MESSAGE_EVENT, {
          type: VscodeDebuggerMessageType.Error,
          message: message.sobject.Description
        } as VscodeDebuggerMessage)
      );
    }
    this.mySessionService.forceStop();
    this.sendEvent(new TerminatedEvent());
  }

protected quitEvent() {
		this.quit = true;
		this.sendEvent(new TerminatedEvent());
	}

terminate(msg) {
        this.sendEvent(new OutputEvent(msg));
        this.sendEvent(new TerminatedEvent());
    }
}

private handleExecutionResult(commandName: string, response: DebugProtocol.Response, result: IExecutionResult) {
        result = result || {};
        if (Array.isArray(result.consoleOutput) && result.consoleOutput.length > 0) {
            this.sendEvent(new OutputEvent(result.consoleOutput.join("\n") + "\n"));
        }
        if (Array.isArray(result.errors) && result.errors.length > 0) {
            this.sendErrorResponse(response, 1, result.errors.join("\n"));
            this.sendEvent(new StoppedEvent("exception", PythonDebugSession.THREAD_ID));
            return;
        }
        if (result.completed === true) {
            this.sendResponse(response);
            this.sendEvent(new TerminatedEvent());
            return;
        }

        this.sendResponse(response);
        this.sendEvent(new StoppedEvent(commandName, PythonDebugSession.THREAD_ID));
    }

protected quitEvent() {
        if (traceThreads) {
            this.handleMsg('log', '**** quit event\n');
        }
        this.quit = true;
        this.sendEvent(new TerminatedEvent());
    }

private stopDebugServer() {
        if (this.debugClient) {
            this.debugClient!.Stop();
            this.debugClient = undefined;
        }
        if (this.pythonProcess) {
            this.pythonProcess!.Kill();
            this.pythonProcess = undefined;
        }
        this.terminateEventSent = true;
        this.sendEvent(new TerminatedEvent());
    }
    private InitializeEventHandlers() {