How to use the vscode-jsonrpc.RequestType function in vscode-jsonrpc

total_time: number,
  tactics: LtacProfTactic[]
}


export namespace InterruptCoqRequest {
  export const type = new RequestType('coqtop/interrupt');
}
export namespace QuitCoqRequest {
  export const type = new RequestType('coqtop/quitCoq')
}
export namespace ResetCoqRequest {
  export const type = new RequestType('coqtop/resetCoq')
}
export namespace StepForwardRequest {
  export const type = new RequestType('coqtop/stepForward')
}
export namespace StepBackwardRequest {
  export const type = new RequestType('coqtop/stepBackward')
}
export namespace InterpretToPointRequest {
  export const type = new RequestType('coqtop/interpretToPoint')
}
export namespace InterpretToEndRequest {
  export const type = new RequestType('coqtop/interpretToEnd')
}
export namespace GoalRequest {
  export const type = new RequestType('coqtop/goal')
}
export interface CachedGoalParams extends CoqTopParams {
  position: vscode.Position,
  direction: "preceding"|"subsequent",

*/
export interface CodeLensRegistrationOptions extends TextDocumentRegistrationOptions, CodeLensOptions {
}

/**
 * A request to provide code lens for the given text document.
 */
export namespace CodeLensRequest {
	export const type = new RequestType('textDocument/codeLens');
}

/**
 * A request to resolve a command for a given code lens.
 */
export namespace CodeLensResolveRequest {
	export const type = new RequestType('codeLens/resolve');
}

//---- Formatting ----------------------------------------------

export interface DocumentFormattingParams {
	/**
	 * The document to format.
	 */
	textDocument: TextDocumentIdentifier;

	/**
	 * The format options
	 */
	options: FormattingOptions;
}

element: string;
  usage: number;
}

export const HistoryEntryGetRequestType: RequestType0<
  HistoryEntryItem[],
  any,
  any
> = new RequestType0('zenscript/getHistoryEntries');

export const HistoryEntryAddRequestType: RequestType<
  string,
  HistoryEntryItem[],
  any,
  any
> = new RequestType('zenscript/addHistoryEntry');

/**
	 * Options necessary for the registration.
	 */
	registerOptions?: any;
}

export interface RegistrationParams {
	registrations: Registration[];
}

/**
 * The `client/registerCapability` request is sent from the server to the client to register a new capability
 * handler on the client side.
 */
export namespace RegistrationRequest {
	export const type = new RequestType('client/registerCapability');
}

/**
 * General parameters to unregister a request or notification.
 */
export interface Unregistration {
	/**
	 * The id used to unregister the request or notification. Usually an id
	 * provided during the register request.
	 */
	id: string;

	/**
	 * The method to unregister for.
	 */
	method: string;

export namespace WillSaveTextDocumentNotification {
	export const method: 'textDocument/willSave' = 'textDocument/willSave';
	export const type = new NotificationType(method);
}

/**
 * A document will save request is sent from the client to the server before
 * the document is actually saved. The request can return an array of TextEdits
 * which will be applied to the text document before it is saved. Please note that
 * clients might drop results if computing the text edits took too long or if a
 * server constantly fails on this request. This is done to keep the save fast and
 * reliable.
 */
export namespace WillSaveTextDocumentWaitUntilRequest {
	export const method: 'textDocument/willSaveWaitUntil' = 'textDocument/willSaveWaitUntil';
	export const type = new RequestType(method);
}

//---- File eventing ----

export interface DidChangeWatchedFilesClientCapabilities {
	/**
	 * Did change watched files notification supports dynamic registration. Please note
	 * that the current protocol doesn't support static configuration for file changes
	 * from the server side.
	 */
	dynamicRegistration?: boolean;
}

/**
 * The watched files notification is sent from the client to the server when
 * the client detects changes to file watched by the language client.

export const type = new RequestType('coqtop/resetCoq')
}
export namespace StepForwardRequest {
  export const type = new RequestType('coqtop/stepForward')
}
export namespace StepBackwardRequest {
  export const type = new RequestType('coqtop/stepBackward')
}
export namespace InterpretToPointRequest {
  export const type = new RequestType('coqtop/interpretToPoint')
}
export namespace InterpretToEndRequest {
  export const type = new RequestType('coqtop/interpretToEnd')
}
export namespace GoalRequest {
  export const type = new RequestType('coqtop/goal')
}
export interface CachedGoalParams extends CoqTopParams {
  position: vscode.Position,
  direction: "preceding"|"subsequent",
}
export namespace CachedGoalRequest {
  export const type = new RequestType('coqtop/cachedGoal')
}
export namespace FinishComputationsRequest {
  export const type = new RequestType('coqtop/finishComputations')
}
export namespace QueryRequest {
  export const type = new RequestType('coqtop/query')
}
export type QueryFunction = "locate"|"check"|"print"|"search"|"about"|"searchAbout";
export interface CoqTopQueryParams extends CoqTopParams {

export namespace PublishAsyncRequest {
            export const type = new RequestType('server/publishAsync');
        }
        /**
         * Get a list of all downloadable runtimes
         * @return
         */
        export namespace ListDownloadableRuntimesRequest {
            export const type = new RequestType('server/listDownloadableRuntimes');
        }
        /**
         * Initiate a request to download a runtime
         * @return
         */
        export namespace DownloadRuntimeRequest {
            export const type = new RequestType('server/downloadRuntime');
        }
        /**
         * Get a list of server action items
         * @return
         */
        export namespace ListServerActionsRequest {
            export const type = new RequestType('server/listServerActions');
        }
        /**
         * Initiate a request to download a runtime
         * @return
         */
        export namespace ExecuteServerActionRequest {
            export const type = new RequestType('server/executeServerAction');
        }
        /**

export interface MoveParam {
    from: string;
    to: string;
}

export namespace СpRequest {
    export const type = new RequestType('fileSystem/cp');
}

export namespace RenameRequest {
    export const type = new RequestType('fileSystem/rename');
}

export namespace MkdirRequest {
    export const type = new RequestType('fileSystem/mkdir');
}

export namespace RmdirRequest {
    export const type = new RequestType('fileSystem/rmdir');
}

export interface WriteFileParam extends PathParam {
    content: string;
    encoding?: string;
}

export namespace WriteFileRequest {
    export const type = new RequestType('fileSystem/writeFile');
}

export interface DidChangeFilesParam {

* RSP itself.
         */
        export namespace ShutdownNotification {
            export const type = new NotificationType('server/shutdown');
        }
        /**
         * The `server/getDiscoveryPaths` request is sent by the client to fetch a list
         * of discovery paths that can be searched.
         *
         * Discovery paths exist in the RSP model as paths suitable to be searched for
         * server runtime installations. Additional paths may be added via the
         * `server/addDiscoveryPath` entry point, or removed via the
         * `server/removeDiscoveryPath` entry point.
         */
        export namespace GetDiscoveryPathsRequest {
            export const type = new RequestType, void, void>('server/getDiscoveryPaths');
        }
        /**
         * The `server/findServerBeans` request is sent by the client to fetch a list of
         * server beans for the given path.
         *
         * The RSP model will iterate through a number of `IServerBeanTypeProvider`
         * instances and ask them if they recognize the contents of the folder
         * underlying the discovery path. Any providers that claim to be able to handle
         * the given path will return an object representing the details of this
         * recognized server runtime, its version, etc.
         *
         * The path parameter must be an absolute file-system path, and
         * may not be a relative path.
         */
        export namespace FindServerBeansRequest {
            export const type = new RequestType, void, void>('server/findServerBeans');

}

export namespace CreateNameRequest {
    export const type = new RequestType('fileSystem/createName');
}

export interface ReadFileParam extends PathParam {
    encoding: string
}

export interface ReadFileResult {
    content: string
}

export namespace ReadFileRequest {
    export const type = new RequestType('fileSystem/readFile');
}

export namespace RmRequest {
    export const type = new RequestType('fileSystem/rm');
}

export interface MoveParam {
    from: string;
    to: string;
}

export namespace СpRequest {
    export const type = new RequestType('fileSystem/cp');
}

export namespace RenameRequest {