How to use the vscode-languageserver.DiagnosticSeverity.Warning function in vscode-languageserver

const transformCfnLintSeverity = (errorType: string): DiagnosticSeverity => {
	switch (errorType) {
		case "Warning":
			return DiagnosticSeverity.Warning
		case "Informational":
			return DiagnosticSeverity.Information
		case "Hint":
			return DiagnosticSeverity.Hint
		default:
			// always fallback to error
			return DiagnosticSeverity.Error
	}
}

function assertInstructionCasing(diagnostic: Diagnostic, startLine: number, startCharacter: number, endLine: number, endCharacter: number) {
	assert.equal(diagnostic.code, ValidationCode.LOWERCASE);
	assert.equal(diagnostic.severity, DiagnosticSeverity.Warning);
	assert.equal(diagnostic.source, source);
	assert.equal(diagnostic.message, Validator.getDiagnosticMessage_InstructionCasing());
	assert.equal(diagnostic.range.start.line, startLine);
	assert.equal(diagnostic.range.start.character, startCharacter);
	assert.equal(diagnostic.range.end.line, endLine);
	assert.equal(diagnostic.range.end.character, endCharacter);
}

public getDiagnostics(request: TextDocument): Diagnostic[] {
        let program: Program = this.getProgram(request.uri);

        if (!program) {
            return [];
        }

        let diagnostics: Diagnostic[] = [];
        let errors: Error[] = program.getErrors();

        for (let error of errors) {
            let severity: DiagnosticSeverity = [
                null,
                DiagnosticSeverity.Error,
                DiagnosticSeverity.Warning,
                DiagnosticSeverity.Information,
                DiagnosticSeverity.Hint
            ][error.severity];

            let diagnostic: Diagnostic = {
                range: error.range,
                severity: severity,
                message: error.message
            };

            diagnostics.push(diagnostic);
        }

        return diagnostics;
    }

function convertSeverity(impact: string): DiagnosticSeverity {
    switch (impact) {
        case 'Low':
            return DiagnosticSeverity.Warning;
        case 'Medium':
            return DiagnosticSeverity.Error;
        case 'High':
            return DiagnosticSeverity.Error;
        default:
            return DiagnosticSeverity.Information;
    }
}

schema,
    astWithExecutableDefinitions,
    fragments,
    rules
  )) {
    diagnostics.push(
      ...diagnosticsFromError(error, DiagnosticSeverity.Error, "Validation")
    );
  }

  for (const error of findDeprecatedUsages(
    schema,
    astWithExecutableDefinitions
  )) {
    diagnostics.push(
      ...diagnosticsFromError(error, DiagnosticSeverity.Warning, "Deprecation")
    );
  }

  return diagnostics;
}

ava('basic shadowed test', (t) => {
  const shadowedSource = readFileSync(shadowPath, 'utf8');
  const results = resolveSource(shadowedSource);

  t.is(0, results.scan.scanErrors.length);
  t.is(0, results.parse.parseErrors.length);
  t.true(results.resolveError.length > 0);

  for (const [error, location] of zip(results.resolveError, shadowedLocations)) {
    t.is(DiagnosticSeverity.Warning, error.severity);
    t.deepEqual(location.start, error.range.start);
    t.deepEqual(location.end, error.range.end);
  }
});

return Object.keys(invalidKeys).map(invalidKey =>
    Diagnostic.create(
      getRange(invalidKey, document),
      `'${invalidKey}' is not a valid top-level key.`,
      DiagnosticSeverity.Warning
    )
  );

convertSeverity(severity: Severity): DiagnosticSeverity {
    switch (severity) {
      case Severity.ERROR:
        return DiagnosticSeverity.Error;
      case Severity.WARNING:
        return DiagnosticSeverity.Warning;
      case Severity.INFO:
        return DiagnosticSeverity.Information;
      default:
        throw new Error(
            `This should never happen. Got a severity of ${severity}`);
    }
  }

function makeDiagnostic(problem): Diagnostic {
	const source = problem.usage.source;
	const message: string = problem.message.replace(/<input>:\d*:\d*:\s/, '');

	const severityLevel = {
		Error: DiagnosticSeverity.Error,
		Information: DiagnosticSeverity.Information,
		Warning: DiagnosticSeverity.Warning
	};

	return {
		severity: severityLevel[editorSettings.messageLevel],
		message,
		range: {
			start: {
				line: source.start.line - 1,
				character: source.start.column - 1
			},
			end: {
				line: source.end.line - 1,
				character: source.end.column
			}
		},
		code: problem.feature,