How to use the rsp-client.StatusSeverity.isOk function in rsp-client

return;
            }

            // var fileUrl = require('file-url');
            // const filePath : string = fileUrl(file[0].fsPath);
            const deployableRef: Protocol.DeployableReference = {
                label: file[0].fsPath,
                path: file[0].fsPath,
                options: options
            };
            const req: Protocol.ServerDeployableReference = {
                server: state.server,
                deployableReference : deployableRef
            };
            const status = await client.getOutgoingHandler().addDeployable(req);
            if (!StatusSeverity.isOk(status)) {
                return Promise.reject(status.message);
            }
            return status;
        }
    }

private async removeStoppedServer(rspId: string, server: Protocol.ServerHandle): Promise {
        const status1: ServerStateNode = this.explorer.getServerStateById(rspId, server.id);
        if (status1.state !== ServerState.STOPPED) {
            return Promise.reject(`Stop server ${server.id} before removing it.`);
        }
        const client: RSPClient = this.explorer.getClientByRSP(rspId);
        if (!client) {
            return Promise.reject('Failed to contact the RSP server.');
        }
        const status = await client.getOutgoingHandler().deleteServer({ id: server.id, type: server.type });
        if (!StatusSeverity.isOk(status)) {
            return Promise.reject(status.message);
        }
        return status;
    }

}

        const client: RSPClient = this.explorer.getClientByRSP(context.rsp);
        if (!client) {
            return Promise.reject('Failed to contact the RSP server.');
        }

        const response = await client.getOutgoingHandler().startServerAsync({
            params: {
                serverType: context.server.type.id,
                id: context.server.id,
                attributes: new Map()
            },
            mode: mode
        });
        if (!StatusSeverity.isOk(response.status)) {
            return Promise.reject(response.status.message);
        }
        return response;
    }

private async createServer(bean: Protocol.ServerBean, name: string, attributes: any = {}, client: RSPClient): Promise {
        if (!bean || !name) {
            throw new Error('Couldn\'t create server: no type or name provided.');
        }
        const response = await client.getServerCreation().createServerFromBeanAsync(bean, name, attributes);
        if (!StatusSeverity.isOk(response.status)) {
            throw new Error(response.status.message);
        }
        return response.status;
    }

const serverState = this.explorer.getServerStateById(context.rsp, context.server.id).state;
        if ((!forced && serverState === ServerState.STARTED)
            || (forced && (serverState === ServerState.STARTING
                            || serverState === ServerState.STOPPING))) {
            const client: RSPClient = this.explorer.getClientByRSP(context.rsp);
            if (!client) {
                return Promise.reject('Failed to contact the RSP server.');
            }
            const status = await client.getOutgoingHandler().stopServerAsync(
                { id: context.server.id, force: forced }
            );
            if (this.debugSession.isDebuggerStarted()) {
                await this.debugSession.stop();
            }
            if (!StatusSeverity.isOk(status)) {
                return Promise.reject(status.message);
            }
            return status;
        } else {
            return Promise.reject('The server is already stopped.');
        }
    }

private onJobRemoved(jobRemoved: Protocol.JobRemoved) {
        if (!this.isJob(jobRemoved.handle)) {
            return;
        }
        this.clearTimeout();
        if (!StatusSeverity.isOk(jobRemoved.status)) {
            this.reject(this.getErrorMessage(jobRemoved.status));
        } else {
            this.resolve(this.job);
        }
    }

public async removeDeployment(rspId: string, server: Protocol.ServerHandle, deployableRef: Protocol.DeployableReference): Promise {
        const client: RSPClient = this.getClientByRSP(rspId);
        if (!client) {
            return Promise.reject('Unable to contact the RSP server.');
        }
        const req: Protocol.ServerDeployableReference = {
            server: server,
            deployableReference : deployableRef
        };
        const status = await client.getOutgoingHandler().removeDeployable(req);
        if (!StatusSeverity.isOk(status)) {
            return Promise.reject(status.message);
        }
        return status;
    }