<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Constant Field Values (Apache Jena - Fuseki Core Engine 5.0.0-rc1)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="summary of constants">
<meta name="generator" content="javadoc/ConstantsSummaryWriterImpl">
<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="script.js"></script>
<script type="text/javascript" src="script-dir/jquery-3.6.1.min.js"></script>
<script type="text/javascript" src="script-dir/jquery-ui.min.js"></script>
</head>
<body class="constants-summary-page">
<script type="text/javascript">var pathtoroot = "./";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="org.apache.jena.fuseki.core/module-summary.html">Module</a></li>
<li>Package</li>
<li>Class</li>
<li>Use</li>
<li><a href="overview-tree.html">Tree</a></li>
<li><a href="index-all.html">Index</a></li>
<li><a href="help-doc.html#constant-values">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<div class="header">
<h1 title="Constant Field Values" class="title">Constant Field Values</h1>
<section class="packages">
<h2 title="Contents">Contents</h2>
<ul>
<li><a href="#org.apache">org.apache.*</a></li>
</ul>
</section>
</div>
<section class="constants-summary" id="org.apache.jena.fuseki">
<h2 title="org.apache">org.apache.*</h2>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.jena.fuseki.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/Fuseki.html" title="class in org.apache.jena.fuseki">Fuseki</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.Fuseki.attrAuthorizationService">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/Fuseki.html#attrAuthorizationService">attrAuthorizationService</a></code></div>
<div class="col-last even-row-color"><code>"org.apache.jena.fuseki:AuthorizationService"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.Fuseki.attrNameRegistry">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/Fuseki.html#attrNameRegistry">attrNameRegistry</a></code></div>
<div class="col-last odd-row-color"><code>"org.apache.jena.fuseki:DataAccessPointRegistry"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.Fuseki.attrOperationRegistry">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/Fuseki.html#attrOperationRegistry">attrOperationRegistry</a></code></div>
<div class="col-last even-row-color"><code>"org.apache.jena.fuseki:OperationRegistry"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.Fuseki.attrVerbose">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/Fuseki.html#attrVerbose">attrVerbose</a></code></div>
<div class="col-last odd-row-color"><code>"org.apache.jena.fuseki:verbose"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.Fuseki.BaseParserSPARQL">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/Fuseki.html#BaseParserSPARQL">BaseParserSPARQL</a></code></div>
<div class="col-last even-row-color"><code>"http://server/unset-base/"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.Fuseki.BaseUpload">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/Fuseki.html#BaseUpload">BaseUpload</a></code></div>
<div class="col-last odd-row-color"><code>"http://server/unset-base/"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.Fuseki.CORS_ENABLED">public&nbsp;static&nbsp;final&nbsp;boolean</code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/Fuseki.html#CORS_ENABLED">CORS_ENABLED</a></code></div>
<div class="col-last even-row-color"><code>false</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.Fuseki.GSP_DIRECT_NAMING">public&nbsp;static&nbsp;final&nbsp;boolean</code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/Fuseki.html#GSP_DIRECT_NAMING">GSP_DIRECT_NAMING</a></code></div>
<div class="col-last odd-row-color"><code>false</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.Fuseki.NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/Fuseki.html#NAME">NAME</a></code></div>
<div class="col-last even-row-color"><code>"Apache Jena Fuseki"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.jena.fuseki.auth.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/auth/Auth.html" title="class in org.apache.jena.fuseki.auth">Auth</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.auth.Auth.dftRealm">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/auth/Auth.html#dftRealm">dftRealm</a></code></div>
<div class="col-last even-row-color"><code>"TripleStore"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.jena.fuseki.ctl.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/ctl/ActionSleep.html" title="class in org.apache.jena.fuseki.ctl">ActionSleep</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.ctl.ActionSleep.MaxSleepMillis">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/ctl/ActionSleep.html#MaxSleepMillis">MaxSleepMillis</a></code></div>
<div class="col-last even-row-color"><code>20000</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.jena.fuseki.ctl.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/ctl/JsonConstCtl.html" title="class in org.apache.jena.fuseki.ctl">JsonConstCtl</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.ctl.JsonConstCtl.finished">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/ctl/JsonConstCtl.html#finished">finished</a></code></div>
<div class="col-last even-row-color"><code>"finished"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.ctl.JsonConstCtl.started">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/ctl/JsonConstCtl.html#started">started</a></code></div>
<div class="col-last odd-row-color"><code>"started"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.ctl.JsonConstCtl.success">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/ctl/JsonConstCtl.html#success">success</a></code></div>
<div class="col-last even-row-color"><code>"success"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.ctl.JsonConstCtl.task">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/ctl/JsonConstCtl.html#task">task</a></code></div>
<div class="col-last odd-row-color"><code>"task"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.ctl.JsonConstCtl.taskId">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/ctl/JsonConstCtl.html#taskId">taskId</a></code></div>
<div class="col-last even-row-color"><code>"taskId"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.ctl.JsonConstCtl.taskRequestId">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/ctl/JsonConstCtl.html#taskRequestId">taskRequestId</a></code></div>
<div class="col-last odd-row-color"><code>"requestId"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.jena.fuseki.server.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html" title="class in org.apache.jena.fuseki.server">ServerConst</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.datasets">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#datasets">datasets</a></code></div>
<div class="col-last even-row-color"><code>"datasets"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.description">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#description">description</a></code></div>
<div class="col-last odd-row-color"><code>"description"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.dsName">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#dsName">dsName</a></code></div>
<div class="col-last even-row-color"><code>"ds.name"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.dsService">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#dsService">dsService</a></code></div>
<div class="col-last odd-row-color"><code>"ds.services"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.dsState">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#dsState">dsState</a></code></div>
<div class="col-last even-row-color"><code>"ds.state"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.endpoints">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#endpoints">endpoints</a></code></div>
<div class="col-last odd-row-color"><code>"endpoints"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.opDump">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#opDump">opDump</a></code></div>
<div class="col-last even-row-color"><code>"dump"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.operation">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#operation">operation</a></code></div>
<div class="col-last odd-row-color"><code>"operation"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.opPing">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#opPing">opPing</a></code></div>
<div class="col-last even-row-color"><code>"ping"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.opStats">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#opStats">opStats</a></code></div>
<div class="col-last odd-row-color"><code>"stats"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.srvDescription">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#srvDescription">srvDescription</a></code></div>
<div class="col-last even-row-color"><code>"srv.description"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.srvEndpoints">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#srvEndpoints">srvEndpoints</a></code></div>
<div class="col-last odd-row-color"><code>"srv.endpoints"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.server.ServerConst.srvType">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/server/ServerConst.html#srvType">srvType</a></code></div>
<div class="col-last even-row-color"><code>"srv.type"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.jena.fuseki.servlets.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html" title="class in org.apache.jena.fuseki.servlets">CrossOriginFilter</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ACCESS_CONTROL_ALLOW_CREDENTIALS_HEADER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ACCESS_CONTROL_ALLOW_CREDENTIALS_HEADER">ACCESS_CONTROL_ALLOW_CREDENTIALS_HEADER</a></code></div>
<div class="col-last even-row-color"><code>"Access-Control-Allow-Credentials"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ACCESS_CONTROL_ALLOW_HEADERS_HEADER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ACCESS_CONTROL_ALLOW_HEADERS_HEADER">ACCESS_CONTROL_ALLOW_HEADERS_HEADER</a></code></div>
<div class="col-last odd-row-color"><code>"Access-Control-Allow-Headers"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ACCESS_CONTROL_ALLOW_METHODS_HEADER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ACCESS_CONTROL_ALLOW_METHODS_HEADER">ACCESS_CONTROL_ALLOW_METHODS_HEADER</a></code></div>
<div class="col-last even-row-color"><code>"Access-Control-Allow-Methods"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ACCESS_CONTROL_ALLOW_ORIGIN_HEADER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ACCESS_CONTROL_ALLOW_ORIGIN_HEADER">ACCESS_CONTROL_ALLOW_ORIGIN_HEADER</a></code></div>
<div class="col-last odd-row-color"><code>"Access-Control-Allow-Origin"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ACCESS_CONTROL_EXPOSE_HEADERS_HEADER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ACCESS_CONTROL_EXPOSE_HEADERS_HEADER">ACCESS_CONTROL_EXPOSE_HEADERS_HEADER</a></code></div>
<div class="col-last even-row-color"><code>"Access-Control-Expose-Headers"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ACCESS_CONTROL_MAX_AGE_HEADER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ACCESS_CONTROL_MAX_AGE_HEADER">ACCESS_CONTROL_MAX_AGE_HEADER</a></code></div>
<div class="col-last odd-row-color"><code>"Access-Control-Max-Age"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ACCESS_CONTROL_REQUEST_HEADERS_HEADER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ACCESS_CONTROL_REQUEST_HEADERS_HEADER">ACCESS_CONTROL_REQUEST_HEADERS_HEADER</a></code></div>
<div class="col-last even-row-color"><code>"Access-Control-Request-Headers"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ACCESS_CONTROL_REQUEST_METHOD_HEADER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ACCESS_CONTROL_REQUEST_METHOD_HEADER">ACCESS_CONTROL_REQUEST_METHOD_HEADER</a></code></div>
<div class="col-last odd-row-color"><code>"Access-Control-Request-Method"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ALLOW_CREDENTIALS_PARAM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ALLOW_CREDENTIALS_PARAM">ALLOW_CREDENTIALS_PARAM</a></code></div>
<div class="col-last even-row-color"><code>"allowCredentials"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ALLOWED_HEADERS_PARAM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ALLOWED_HEADERS_PARAM">ALLOWED_HEADERS_PARAM</a></code></div>
<div class="col-last odd-row-color"><code>"allowedHeaders"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ALLOWED_METHODS_PARAM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ALLOWED_METHODS_PARAM">ALLOWED_METHODS_PARAM</a></code></div>
<div class="col-last even-row-color"><code>"allowedMethods"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ALLOWED_ORIGINS_PARAM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ALLOWED_ORIGINS_PARAM">ALLOWED_ORIGINS_PARAM</a></code></div>
<div class="col-last odd-row-color"><code>"allowedOrigins"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.ALLOWED_TIMING_ORIGINS_PARAM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#ALLOWED_TIMING_ORIGINS_PARAM">ALLOWED_TIMING_ORIGINS_PARAM</a></code></div>
<div class="col-last even-row-color"><code>"allowedTimingOrigins"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.CHAIN_PREFLIGHT_PARAM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#CHAIN_PREFLIGHT_PARAM">CHAIN_PREFLIGHT_PARAM</a></code></div>
<div class="col-last odd-row-color"><code>"chainPreflight"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.EXPOSED_HEADERS_PARAM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#EXPOSED_HEADERS_PARAM">EXPOSED_HEADERS_PARAM</a></code></div>
<div class="col-last even-row-color"><code>"exposedHeaders"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.OLD_CHAIN_PREFLIGHT_PARAM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#OLD_CHAIN_PREFLIGHT_PARAM">OLD_CHAIN_PREFLIGHT_PARAM</a></code></div>
<div class="col-last odd-row-color"><code>"forwardPreflight"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.PREFLIGHT_MAX_AGE_PARAM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#PREFLIGHT_MAX_AGE_PARAM">PREFLIGHT_MAX_AGE_PARAM</a></code></div>
<div class="col-last even-row-color"><code>"preflightMaxAge"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.CrossOriginFilter.TIMING_ALLOW_ORIGIN_HEADER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/CrossOriginFilter.html#TIMING_ALLOW_ORIGIN_HEADER">TIMING_ALLOW_ORIGIN_HEADER</a></code></div>
<div class="col-last odd-row-color"><code>"Timing-Allow-Origin"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.jena.fuseki.servlets.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/ServletBase.html" title="class in org.apache.jena.fuseki.servlets">ServletBase</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.ServletBase.METHOD_DELETE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/ServletBase.html#METHOD_DELETE">METHOD_DELETE</a></code></div>
<div class="col-last even-row-color"><code>"DELETE"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.ServletBase.METHOD_GET">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/ServletBase.html#METHOD_GET">METHOD_GET</a></code></div>
<div class="col-last odd-row-color"><code>"GET"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.ServletBase.METHOD_HEAD">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/ServletBase.html#METHOD_HEAD">METHOD_HEAD</a></code></div>
<div class="col-last even-row-color"><code>"HEAD"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.ServletBase.METHOD_OPTIONS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/ServletBase.html#METHOD_OPTIONS">METHOD_OPTIONS</a></code></div>
<div class="col-last odd-row-color"><code>"OPTIONS"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.ServletBase.METHOD_PATCH">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/ServletBase.html#METHOD_PATCH">METHOD_PATCH</a></code></div>
<div class="col-last even-row-color"><code>"PATCH"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.ServletBase.METHOD_POST">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/ServletBase.html#METHOD_POST">METHOD_POST</a></code></div>
<div class="col-last odd-row-color"><code>"POST"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.servlets.ServletBase.METHOD_PUT">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/ServletBase.html#METHOD_PUT">METHOD_PUT</a></code></div>
<div class="col-last even-row-color"><code>"PUT"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.servlets.ServletBase.METHOD_TRACE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/servlets/ServletBase.html#METHOD_TRACE">METHOD_TRACE</a></code></div>
<div class="col-last odd-row-color"><code>"TRACE"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.jena.fuseki.system.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/system/FusekiLogging.html" title="class in org.apache.jena.fuseki.system">FusekiLogging</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.system.FusekiLogging.log4j2_configurationFile">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/system/FusekiLogging.html#log4j2_configurationFile">log4j2_configurationFile</a></code></div>
<div class="col-last even-row-color"><code>"log4j2.configurationFile"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.system.FusekiLogging.log4j2_web_configuration">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/system/FusekiLogging.html#log4j2_web_configuration">log4j2_web_configuration</a></code></div>
<div class="col-last odd-row-color"><code>"log4jConfiguration"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.jena.fuseki.validation.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/ValidatorBase.html" title="class in org.apache.jena.fuseki.validation">ValidatorBase</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.validation.ValidatorBase.contentTypeHTML">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/ValidatorBase.html#contentTypeHTML">contentTypeHTML</a></code></div>
<div class="col-last even-row-color"><code>"text/html"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.jena.fuseki.validation.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/ValidatorBaseJson.html" title="class in org.apache.jena.fuseki.validation">ValidatorBaseJson</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.validation.ValidatorBaseJson.respService">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/ValidatorBaseJson.html#respService">respService</a></code></div>
<div class="col-last even-row-color"><code>"X-Service"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.jena.fuseki.validation.html.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/html/ValidatorHtmlLib.html" title="class in org.apache.jena.fuseki.validation.html">ValidatorHtmlLib</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.validation.html.ValidatorHtmlLib.cssFile">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/html/ValidatorHtmlLib.html#cssFile">cssFile</a></code></div>
<div class="col-last even-row-color"><code>"../../css/fuseki.css"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.validation.html.ValidatorHtmlLib.jErrors">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/html/ValidatorHtmlLib.html#jErrors">jErrors</a></code></div>
<div class="col-last odd-row-color"><code>"errors"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.validation.html.ValidatorHtmlLib.jParseError">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/html/ValidatorHtmlLib.html#jParseError">jParseError</a></code></div>
<div class="col-last even-row-color"><code>"parse-error"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.validation.html.ValidatorHtmlLib.jParseErrorCol">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/html/ValidatorHtmlLib.html#jParseErrorCol">jParseErrorCol</a></code></div>
<div class="col-last odd-row-color"><code>"parse-error-column"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.validation.html.ValidatorHtmlLib.jParseErrorLine">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/html/ValidatorHtmlLib.html#jParseErrorLine">jParseErrorLine</a></code></div>
<div class="col-last even-row-color"><code>"parse-error-line"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.validation.html.ValidatorHtmlLib.jWarnings">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/html/ValidatorHtmlLib.html#jWarnings">jWarnings</a></code></div>
<div class="col-last odd-row-color"><code>"warning"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.validation.html.ValidatorHtmlLib.respService">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/html/ValidatorHtmlLib.html#respService">respService</a></code></div>
<div class="col-last even-row-color"><code>"X-Service"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.jena.fuseki.validation.json.<a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/json/ValidatorJsonLib.html" title="class in org.apache.jena.fuseki.validation.json">ValidatorJsonLib</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.validation.json.ValidatorJsonLib.jErrors">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/json/ValidatorJsonLib.html#jErrors">jErrors</a></code></div>
<div class="col-last even-row-color"><code>"errors"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.validation.json.ValidatorJsonLib.jParseError">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/json/ValidatorJsonLib.html#jParseError">jParseError</a></code></div>
<div class="col-last odd-row-color"><code>"parse-error"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.validation.json.ValidatorJsonLib.jParseErrorCol">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/json/ValidatorJsonLib.html#jParseErrorCol">jParseErrorCol</a></code></div>
<div class="col-last even-row-color"><code>"parse-error-column"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.validation.json.ValidatorJsonLib.jParseErrorLine">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/json/ValidatorJsonLib.html#jParseErrorLine">jParseErrorLine</a></code></div>
<div class="col-last odd-row-color"><code>"parse-error-line"</code></div>
<div class="col-first even-row-color"><code id="org.apache.jena.fuseki.validation.json.ValidatorJsonLib.jWarnings">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/json/ValidatorJsonLib.html#jWarnings">jWarnings</a></code></div>
<div class="col-last even-row-color"><code>"warning"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.jena.fuseki.validation.json.ValidatorJsonLib.respService">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org.apache.jena.fuseki.core/org/apache/jena/fuseki/validation/json/ValidatorJsonLib.html#respService">respService</a></code></div>
<div class="col-last odd-row-color"><code>"X-Service"</code></div>
</div>
</li>
</ul>
</section>
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Licensed under the Apache License, Version 2.0</small></p>
</footer>
</div>
</div>
</body>
</html>
