<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Constant Field Values (Openmeetings Util 7.2.0 API)</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="index.html">Overview</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.openmeetings.util">
<h2 title="org.apache">org.apache.*</h2>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.util.<a href="org/apache/openmeetings/util/CalendarPatterns.html" title="class in org.apache.openmeetings.util">CalendarPatterns</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.openmeetings.util.CalendarPatterns.FULL_DF_PATTERN">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/openmeetings/util/CalendarPatterns.html#FULL_DF_PATTERN">FULL_DF_PATTERN</a></code></div>
<div class="col-last even-row-color"><code>"dd.MM.yyyy HH:mm:ss z (Z)"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.CalendarPatterns.ISO8601_DATE_FORMAT_STRING">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/openmeetings/util/CalendarPatterns.html#ISO8601_DATE_FORMAT_STRING">ISO8601_DATE_FORMAT_STRING</a></code></div>
<div class="col-last odd-row-color"><code>"yyyy-MM-dd"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.CalendarPatterns.ISO8601_DATETIME_FORMAT_STRING">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/openmeetings/util/CalendarPatterns.html#ISO8601_DATETIME_FORMAT_STRING">ISO8601_DATETIME_FORMAT_STRING</a></code></div>
<div class="col-last even-row-color"><code>"yyyy-MM-dd\'T\'HH:mm:ss"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.CalendarPatterns.ISO8601_FULL_FORMAT_STRING">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/openmeetings/util/CalendarPatterns.html#ISO8601_FULL_FORMAT_STRING">ISO8601_FULL_FORMAT_STRING</a></code></div>
<div class="col-last odd-row-color"><code>"yyyy-MM-dd\'T\'HH:mm:ssZ"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.openmeetings.util.<a href="org/apache/openmeetings/util/OmFileHelper.html" title="class in org.apache.openmeetings.util">OmFileHelper</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.openmeetings.util.OmFileHelper.BACKUP_DIR">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/openmeetings/util/OmFileHelper.html#BACKUP_DIR">BACKUP_DIR</a></code></div>
<div class="col-last even-row-color"><code>"backup"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.BCKP_RECORD_FILES">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/openmeetings/util/OmFileHelper.html#BCKP_RECORD_FILES">BCKP_RECORD_FILES</a></code></div>
<div class="col-last odd-row-color"><code>"recordingFiles"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.BCKP_ROOM_FILES">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/openmeetings/util/OmFileHelper.html#BCKP_ROOM_FILES">BCKP_ROOM_FILES</a></code></div>
<div class="col-last even-row-color"><code>"roomFiles"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.CSS_DIR">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/openmeetings/util/OmFileHelper.html#CSS_DIR">CSS_DIR</a></code></div>
<div class="col-last odd-row-color"><code>"css"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.CUSTOM_CSS">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/openmeetings/util/OmFileHelper.html#CUSTOM_CSS">CUSTOM_CSS</a></code></div>
<div class="col-last even-row-color"><code>"custom.css"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.DASHBOARD_FILE">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/openmeetings/util/OmFileHelper.html#DASHBOARD_FILE">DASHBOARD_FILE</a></code></div>
<div class="col-last odd-row-color"><code>"dashboard.xml"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.DB_PERSISTENCE_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/openmeetings/util/OmFileHelper.html#DB_PERSISTENCE_NAME">DB_PERSISTENCE_NAME</a></code></div>
<div class="col-last even-row-color"><code>"classes/META-INF/%s_persistence.xml"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.DOC_PAGE_PREFIX">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/openmeetings/util/OmFileHelper.html#DOC_PAGE_PREFIX">DOC_PAGE_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"page"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.EXTENSION_CSS">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/openmeetings/util/OmFileHelper.html#EXTENSION_CSS">EXTENSION_CSS</a></code></div>
<div class="col-last even-row-color"><code>"css"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.EXTENSION_JPG">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/openmeetings/util/OmFileHelper.html#EXTENSION_JPG">EXTENSION_JPG</a></code></div>
<div class="col-last odd-row-color"><code>"jpg"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.EXTENSION_MP4">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/openmeetings/util/OmFileHelper.html#EXTENSION_MP4">EXTENSION_MP4</a></code></div>
<div class="col-last even-row-color"><code>"mp4"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.EXTENSION_PDF">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/openmeetings/util/OmFileHelper.html#EXTENSION_PDF">EXTENSION_PDF</a></code></div>
<div class="col-last odd-row-color"><code>"pdf"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.EXTENSION_PNG">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/openmeetings/util/OmFileHelper.html#EXTENSION_PNG">EXTENSION_PNG</a></code></div>
<div class="col-last even-row-color"><code>"png"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.EXTENSION_WEBM">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/openmeetings/util/OmFileHelper.html#EXTENSION_WEBM">EXTENSION_WEBM</a></code></div>
<div class="col-last odd-row-color"><code>"webm"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.EXTENSION_WML">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/openmeetings/util/OmFileHelper.html#EXTENSION_WML">EXTENSION_WML</a></code></div>
<div class="col-last even-row-color"><code>"wml"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.FILE_NAME_FMT">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/openmeetings/util/OmFileHelper.html#FILE_NAME_FMT">FILE_NAME_FMT</a></code></div>
<div class="col-last odd-row-color"><code>"%s.%s"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.FILES_DIR">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/openmeetings/util/OmFileHelper.html#FILES_DIR">FILES_DIR</a></code></div>
<div class="col-last even-row-color"><code>"files"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.GROUP_CSS_PREFIX">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/openmeetings/util/OmFileHelper.html#GROUP_CSS_PREFIX">GROUP_CSS_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"customcss"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.GROUP_LOGO_DIR">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/openmeetings/util/OmFileHelper.html#GROUP_LOGO_DIR">GROUP_LOGO_DIR</a></code></div>
<div class="col-last even-row-color"><code>"grouplogo"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.GROUP_LOGO_PREFIX">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/openmeetings/util/OmFileHelper.html#GROUP_LOGO_PREFIX">GROUP_LOGO_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"logo"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.HIBERNATE">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/openmeetings/util/OmFileHelper.html#HIBERNATE">HIBERNATE</a></code></div>
<div class="col-last even-row-color"><code>"hibernate"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.IMPORT_DIR">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/openmeetings/util/OmFileHelper.html#IMPORT_DIR">IMPORT_DIR</a></code></div>
<div class="col-last odd-row-color"><code>"import"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.JPG_MIME_TYPE">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/openmeetings/util/OmFileHelper.html#JPG_MIME_TYPE">JPG_MIME_TYPE</a></code></div>
<div class="col-last even-row-color"><code>"image/jpeg"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.LANG_FILE_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 odd-row-color"><code><a href="org/apache/openmeetings/util/OmFileHelper.html#LANG_FILE_NAME">LANG_FILE_NAME</a></code></div>
<div class="col-last odd-row-color"><code>"languages.xml"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.LIBRARY_FILE_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/openmeetings/util/OmFileHelper.html#LIBRARY_FILE_NAME">LIBRARY_FILE_NAME</a></code></div>
<div class="col-last even-row-color"><code>"library.xml"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.MP4_MIME_TYPE">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/openmeetings/util/OmFileHelper.html#MP4_MIME_TYPE">MP4_MIME_TYPE</a></code></div>
<div class="col-last odd-row-color"><code>"video/mp4"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.PERSISTENCE_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/openmeetings/util/OmFileHelper.html#PERSISTENCE_NAME">PERSISTENCE_NAME</a></code></div>
<div class="col-last even-row-color"><code>"classes/META-INF/persistence.xml"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.PNG_MIME_TYPE">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/openmeetings/util/OmFileHelper.html#PNG_MIME_TYPE">PNG_MIME_TYPE</a></code></div>
<div class="col-last odd-row-color"><code>"image/png"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.PROFILE_FILE_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/openmeetings/util/OmFileHelper.html#PROFILE_FILE_NAME">PROFILE_FILE_NAME</a></code></div>
<div class="col-last even-row-color"><code>"profile"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.PROFILE_IMG_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 odd-row-color"><code><a href="org/apache/openmeetings/util/OmFileHelper.html#PROFILE_IMG_NAME">PROFILE_IMG_NAME</a></code></div>
<div class="col-last odd-row-color"><code>"profile.png"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.PROFILES_DIR">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/openmeetings/util/OmFileHelper.html#PROFILES_DIR">PROFILES_DIR</a></code></div>
<div class="col-last even-row-color"><code>"profiles"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.PROFILES_PREFIX">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/openmeetings/util/OmFileHelper.html#PROFILES_PREFIX">PROFILES_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"profile_"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.RECORDING_FILE_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/openmeetings/util/OmFileHelper.html#RECORDING_FILE_NAME">RECORDING_FILE_NAME</a></code></div>
<div class="col-last even-row-color"><code>"flvRecording_"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.SCREENSHARING_DIR">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/openmeetings/util/OmFileHelper.html#SCREENSHARING_DIR">SCREENSHARING_DIR</a></code></div>
<div class="col-last odd-row-color"><code>"screensharing"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.SIP_PICTURE_URI">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/openmeetings/util/OmFileHelper.html#SIP_PICTURE_URI">SIP_PICTURE_URI</a></code></div>
<div class="col-last even-row-color"><code>"phone.png"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.TEST_SETUP_PREFIX">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/openmeetings/util/OmFileHelper.html#TEST_SETUP_PREFIX">TEST_SETUP_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"TEST_SETUP_"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.THUMB_IMG_PREFIX">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/openmeetings/util/OmFileHelper.html#THUMB_IMG_PREFIX">THUMB_IMG_PREFIX</a></code></div>
<div class="col-last even-row-color"><code>"_thumb_"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.WB_VIDEO_FILE_PREFIX">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/openmeetings/util/OmFileHelper.html#WB_VIDEO_FILE_PREFIX">WB_VIDEO_FILE_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"UPLOADFLV_"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OmFileHelper.WML_DIR">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/openmeetings/util/OmFileHelper.html#WML_DIR">WML_DIR</a></code></div>
<div class="col-last even-row-color"><code>"stored"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.openmeetings.util.<a href="org/apache/openmeetings/util/OpenmeetingsVariables.html" title="class in org.apache.openmeetings.util">OpenmeetingsVariables</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.openmeetings.util.OpenmeetingsVariables.ATTR_CLASS">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/openmeetings/util/OpenmeetingsVariables.html#ATTR_CLASS">ATTR_CLASS</a></code></div>
<div class="col-last even-row-color"><code>"class"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.ATTR_DISABLED">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/openmeetings/util/OpenmeetingsVariables.html#ATTR_DISABLED">ATTR_DISABLED</a></code></div>
<div class="col-last odd-row-color"><code>"disabled"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.ATTR_TITLE">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/openmeetings/util/OpenmeetingsVariables.html#ATTR_TITLE">ATTR_TITLE</a></code></div>
<div class="col-last even-row-color"><code>"title"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.ATTR_VALUE">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/openmeetings/util/OpenmeetingsVariables.html#ATTR_VALUE">ATTR_VALUE</a></code></div>
<div class="col-last odd-row-color"><code>"value"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_APPLICATION_BASE_URL">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_APPLICATION_BASE_URL">CONFIG_APPLICATION_BASE_URL</a></code></div>
<div class="col-last even-row-color"><code>"application.base.url"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_APPLICATION_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 odd-row-color"><code><a href="org/apache/openmeetings/util/OpenmeetingsVariables.html#CONFIG_APPLICATION_NAME">CONFIG_APPLICATION_NAME</a></code></div>
<div class="col-last odd-row-color"><code>"application.name"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_APPOINTMENT_PRE_START_MINUTES">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_APPOINTMENT_PRE_START_MINUTES">CONFIG_APPOINTMENT_PRE_START_MINUTES</a></code></div>
<div class="col-last even-row-color"><code>"appointment.pre.start.minutes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_APPOINTMENT_REMINDER_MINUTES">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_APPOINTMENT_REMINDER_MINUTES">CONFIG_APPOINTMENT_REMINDER_MINUTES</a></code></div>
<div class="col-last odd-row-color"><code>"number.minutes.reminder.send"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_AUTO_OPEN_SHARING">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_AUTO_OPEN_SHARING">CONFIG_AUTO_OPEN_SHARING</a></code></div>
<div class="col-last even-row-color"><code>"auto.open.sharing"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CALENDAR_ROOM_CAPACITY">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CALENDAR_ROOM_CAPACITY">CONFIG_CALENDAR_ROOM_CAPACITY</a></code></div>
<div class="col-last odd-row-color"><code>"calendar.conference.rooms.default.size"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CAM_FPS">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CAM_FPS">CONFIG_CAM_FPS</a></code></div>
<div class="col-last even-row-color"><code>"cam.fps"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CHAT_SEND_ON_ENTER">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CHAT_SEND_ON_ENTER">CONFIG_CHAT_SEND_ON_ENTER</a></code></div>
<div class="col-last odd-row-color"><code>"chat.send.on.enter"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CRYPT">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CRYPT">CONFIG_CRYPT</a></code></div>
<div class="col-last even-row-color"><code>"crypt.class.name"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CSP_ENABLED">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CSP_ENABLED">CONFIG_CSP_ENABLED</a></code></div>
<div class="col-last odd-row-color"><code>"header.csp.enabled"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CSP_FONT">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CSP_FONT">CONFIG_CSP_FONT</a></code></div>
<div class="col-last even-row-color"><code>"header.csp.font"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CSP_FRAME">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CSP_FRAME">CONFIG_CSP_FRAME</a></code></div>
<div class="col-last odd-row-color"><code>"header.csp.frame"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CSP_IMAGE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CSP_IMAGE">CONFIG_CSP_IMAGE</a></code></div>
<div class="col-last even-row-color"><code>"header.csp.image"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CSP_MEDIA">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CSP_MEDIA">CONFIG_CSP_MEDIA</a></code></div>
<div class="col-last odd-row-color"><code>"header.csp.media"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CSP_SCRIPT">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CSP_SCRIPT">CONFIG_CSP_SCRIPT</a></code></div>
<div class="col-last even-row-color"><code>"header.csp.script"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_CSP_STYLE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_CSP_STYLE">CONFIG_CSP_STYLE</a></code></div>
<div class="col-last odd-row-color"><code>"header.csp.style"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DASHBOARD_RSS_FEED1">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DASHBOARD_RSS_FEED1">CONFIG_DASHBOARD_RSS_FEED1</a></code></div>
<div class="col-last even-row-color"><code>"dashboard.rss.feed1"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DASHBOARD_RSS_FEED2">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DASHBOARD_RSS_FEED2">CONFIG_DASHBOARD_RSS_FEED2</a></code></div>
<div class="col-last odd-row-color"><code>"dashboard.rss.feed2"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DASHBOARD_SHOW_CHAT">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DASHBOARD_SHOW_CHAT">CONFIG_DASHBOARD_SHOW_CHAT</a></code></div>
<div class="col-last even-row-color"><code>"dashboard.show.chat"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DASHBOARD_SHOW_MYROOMS">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DASHBOARD_SHOW_MYROOMS">CONFIG_DASHBOARD_SHOW_MYROOMS</a></code></div>
<div class="col-last odd-row-color"><code>"dashboard.show.myrooms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DASHBOARD_SHOW_RSS">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DASHBOARD_SHOW_RSS">CONFIG_DASHBOARD_SHOW_RSS</a></code></div>
<div class="col-last even-row-color"><code>"dashboard.show.rssfeed"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DEFAULT_GROUP_ID">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DEFAULT_GROUP_ID">CONFIG_DEFAULT_GROUP_ID</a></code></div>
<div class="col-last odd-row-color"><code>"default.group.id"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DEFAULT_LANDING_ZONE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DEFAULT_LANDING_ZONE">CONFIG_DEFAULT_LANDING_ZONE</a></code></div>
<div class="col-last even-row-color"><code>"default.landing.zone"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DEFAULT_LANG">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DEFAULT_LANG">CONFIG_DEFAULT_LANG</a></code></div>
<div class="col-last odd-row-color"><code>"default.lang.id"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DEFAULT_LDAP_ID">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DEFAULT_LDAP_ID">CONFIG_DEFAULT_LDAP_ID</a></code></div>
<div class="col-last even-row-color"><code>"default.ldap.id"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DEFAULT_TIMEZONE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DEFAULT_TIMEZONE">CONFIG_DEFAULT_TIMEZONE</a></code></div>
<div class="col-last odd-row-color"><code>"default.timezone"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DISPLAY_NAME_EDITABLE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DISPLAY_NAME_EDITABLE">CONFIG_DISPLAY_NAME_EDITABLE</a></code></div>
<div class="col-last even-row-color"><code>"display.name.editable"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DOCUMENT_DPI">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DOCUMENT_DPI">CONFIG_DOCUMENT_DPI</a></code></div>
<div class="col-last odd-row-color"><code>"document.dpi"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_DOCUMENT_QUALITY">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_DOCUMENT_QUALITY">CONFIG_DOCUMENT_QUALITY</a></code></div>
<div class="col-last even-row-color"><code>"document.quality"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_EMAIL_AT_REGISTER">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_EMAIL_AT_REGISTER">CONFIG_EMAIL_AT_REGISTER</a></code></div>
<div class="col-last odd-row-color"><code>"send.email.at.register"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_EMAIL_VERIFICATION">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_EMAIL_VERIFICATION">CONFIG_EMAIL_VERIFICATION</a></code></div>
<div class="col-last even-row-color"><code>"send.email.with.verfication"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_EXT_PROCESS_TTL">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_EXT_PROCESS_TTL">CONFIG_EXT_PROCESS_TTL</a></code></div>
<div class="col-last odd-row-color"><code>"external.process.ttl"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_FNAME_MIN_LENGTH">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_FNAME_MIN_LENGTH">CONFIG_FNAME_MIN_LENGTH</a></code></div>
<div class="col-last even-row-color"><code>"user.fname.minimum.length"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_GOOGLE_ANALYTICS_CODE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_GOOGLE_ANALYTICS_CODE">CONFIG_GOOGLE_ANALYTICS_CODE</a></code></div>
<div class="col-last odd-row-color"><code>"google.analytics.code"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_IGNORE_BAD_SSL">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_IGNORE_BAD_SSL">CONFIG_IGNORE_BAD_SSL</a></code></div>
<div class="col-last even-row-color"><code>"oauth2.ignore.bad.ssl"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_KEYCODE_ARRANGE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_KEYCODE_ARRANGE">CONFIG_KEYCODE_ARRANGE</a></code></div>
<div class="col-last odd-row-color"><code>"video.arrange.keycode"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_KEYCODE_ARRANGE_RESIZE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_KEYCODE_ARRANGE_RESIZE">CONFIG_KEYCODE_ARRANGE_RESIZE</a></code></div>
<div class="col-last even-row-color"><code>"video.arrange.resize.keycode"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_KEYCODE_MUTE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_KEYCODE_MUTE">CONFIG_KEYCODE_MUTE</a></code></div>
<div class="col-last odd-row-color"><code>"mute.keycode"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_KEYCODE_MUTE_OTHERS">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_KEYCODE_MUTE_OTHERS">CONFIG_KEYCODE_MUTE_OTHERS</a></code></div>
<div class="col-last even-row-color"><code>"mute.others.keycode"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_KEYCODE_QUICKPOLL">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_KEYCODE_QUICKPOLL">CONFIG_KEYCODE_QUICKPOLL</a></code></div>
<div class="col-last odd-row-color"><code>"start.quickpoll.keycode"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_LNAME_MIN_LENGTH">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_LNAME_MIN_LENGTH">CONFIG_LNAME_MIN_LENGTH</a></code></div>
<div class="col-last even-row-color"><code>"user.lname.minimum.length"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_LOGIN_MIN_LENGTH">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_LOGIN_MIN_LENGTH">CONFIG_LOGIN_MIN_LENGTH</a></code></div>
<div class="col-last odd-row-color"><code>"user.login.minimum.length"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_MAX_UPLOAD_SIZE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_MAX_UPLOAD_SIZE">CONFIG_MAX_UPLOAD_SIZE</a></code></div>
<div class="col-last even-row-color"><code>"max.upload.size"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_MIC_ECHO">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_MIC_ECHO">CONFIG_MIC_ECHO</a></code></div>
<div class="col-last odd-row-color"><code>"mic.echo.cancellation"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_MIC_NOISE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_MIC_NOISE">CONFIG_MIC_NOISE</a></code></div>
<div class="col-last even-row-color"><code>"mic.noise.suppression"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_MIC_RATE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_MIC_RATE">CONFIG_MIC_RATE</a></code></div>
<div class="col-last odd-row-color"><code>"mic.rate"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_MP4_AUDIO_BITRATE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_MP4_AUDIO_BITRATE">CONFIG_MP4_AUDIO_BITRATE</a></code></div>
<div class="col-last even-row-color"><code>"mp4.audio.bitrate"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_MP4_AUDIO_RATE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_MP4_AUDIO_RATE">CONFIG_MP4_AUDIO_RATE</a></code></div>
<div class="col-last odd-row-color"><code>"mp4.audio.rate"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_MP4_VIDEO_PRESET">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_MP4_VIDEO_PRESET">CONFIG_MP4_VIDEO_PRESET</a></code></div>
<div class="col-last even-row-color"><code>"mp4.video.preset"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_MYROOMS_ENABLED">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_MYROOMS_ENABLED">CONFIG_MYROOMS_ENABLED</a></code></div>
<div class="col-last odd-row-color"><code>"personal.rooms.enabled"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_OTP_ENABLED">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_OTP_ENABLED">CONFIG_OTP_ENABLED</a></code></div>
<div class="col-last even-row-color"><code>"otp.enabled"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_PASS_CHECK_DIGIT">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_PASS_CHECK_DIGIT">CONFIG_PASS_CHECK_DIGIT</a></code></div>
<div class="col-last odd-row-color"><code>"user.pass.check.digit"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_PASS_CHECK_SPECIAL">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_PASS_CHECK_SPECIAL">CONFIG_PASS_CHECK_SPECIAL</a></code></div>
<div class="col-last even-row-color"><code>"user.pass.check.special"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_PASS_CHECK_UPPER">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_PASS_CHECK_UPPER">CONFIG_PASS_CHECK_UPPER</a></code></div>
<div class="col-last odd-row-color"><code>"user.pass.check.upper"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_PASS_MIN_LENGTH">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_PASS_MIN_LENGTH">CONFIG_PASS_MIN_LENGTH</a></code></div>
<div class="col-last even-row-color"><code>"user.pass.minimum.length"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_PATH_FFMPEG">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_PATH_FFMPEG">CONFIG_PATH_FFMPEG</a></code></div>
<div class="col-last odd-row-color"><code>"path.ffmpeg"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_PATH_IMAGEMAGIC">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_PATH_IMAGEMAGIC">CONFIG_PATH_IMAGEMAGIC</a></code></div>
<div class="col-last even-row-color"><code>"path.imagemagick"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_PATH_OFFICE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_PATH_OFFICE">CONFIG_PATH_OFFICE</a></code></div>
<div class="col-last odd-row-color"><code>"path.office"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_PATH_SOX">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_PATH_SOX">CONFIG_PATH_SOX</a></code></div>
<div class="col-last even-row-color"><code>"path.sox"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_RECORDING_ENABLED">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_RECORDING_ENABLED">CONFIG_RECORDING_ENABLED</a></code></div>
<div class="col-last odd-row-color"><code>"recording.enabled"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_REDIRECT_URL_FOR_EXTERNAL">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_REDIRECT_URL_FOR_EXTERNAL">CONFIG_REDIRECT_URL_FOR_EXTERNAL</a></code></div>
<div class="col-last even-row-color"><code>"redirect.url.for.external.users"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_REGISTER_FRONTEND">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_REGISTER_FRONTEND">CONFIG_REGISTER_FRONTEND</a></code></div>
<div class="col-last odd-row-color"><code>"allow.frontend.register"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_REGISTER_OAUTH">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_REGISTER_OAUTH">CONFIG_REGISTER_OAUTH</a></code></div>
<div class="col-last even-row-color"><code>"allow.oauth.register"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_REGISTER_SOAP">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_REGISTER_SOAP">CONFIG_REGISTER_SOAP</a></code></div>
<div class="col-last odd-row-color"><code>"allow.soap.register"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_REMINDER_MESSAGE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_REMINDER_MESSAGE">CONFIG_REMINDER_MESSAGE</a></code></div>
<div class="col-last even-row-color"><code>"reminder.message"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_REPLY_TO_ORGANIZER">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_REPLY_TO_ORGANIZER">CONFIG_REPLY_TO_ORGANIZER</a></code></div>
<div class="col-last odd-row-color"><code>"inviter.email.as.replyto"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_REST_ALLOW_ORIGIN">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_REST_ALLOW_ORIGIN">CONFIG_REST_ALLOW_ORIGIN</a></code></div>
<div class="col-last even-row-color"><code>"rest.allow.origin"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SCREENSHARING_ALLOW_REMOTE">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SCREENSHARING_ALLOW_REMOTE">CONFIG_SCREENSHARING_ALLOW_REMOTE</a></code></div>
<div class="col-last odd-row-color"><code>"screensharing.allow.remote"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SCREENSHARING_FPS">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SCREENSHARING_FPS">CONFIG_SCREENSHARING_FPS</a></code></div>
<div class="col-last even-row-color"><code>"screensharing.default.fps"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SCREENSHARING_FPS_SHOW">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SCREENSHARING_FPS_SHOW">CONFIG_SCREENSHARING_FPS_SHOW</a></code></div>
<div class="col-last odd-row-color"><code>"screensharing.fps.show"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SCREENSHARING_QUALITY">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SCREENSHARING_QUALITY">CONFIG_SCREENSHARING_QUALITY</a></code></div>
<div class="col-last even-row-color"><code>"screensharing.default.quality"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SIP_ENABLED">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SIP_ENABLED">CONFIG_SIP_ENABLED</a></code></div>
<div class="col-last odd-row-color"><code>"sip.enable"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SIP_EXTEN_CONTEXT">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SIP_EXTEN_CONTEXT">CONFIG_SIP_EXTEN_CONTEXT</a></code></div>
<div class="col-last even-row-color"><code>"sip.exten.context"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SIP_ROOM_PREFIX">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SIP_ROOM_PREFIX">CONFIG_SIP_ROOM_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"sip.room.prefix"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SMTP_PASS">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SMTP_PASS">CONFIG_SMTP_PASS</a></code></div>
<div class="col-last even-row-color"><code>"mail.smtp.pass"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SMTP_PORT">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SMTP_PORT">CONFIG_SMTP_PORT</a></code></div>
<div class="col-last odd-row-color"><code>"mail.smtp.port"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SMTP_SERVER">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SMTP_SERVER">CONFIG_SMTP_SERVER</a></code></div>
<div class="col-last even-row-color"><code>"mail.smtp.server"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SMTP_SSL">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SMTP_SSL">CONFIG_SMTP_SSL</a></code></div>
<div class="col-last odd-row-color"><code>"mail.smtp.ssl.enable"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SMTP_SYSTEM_EMAIL">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SMTP_SYSTEM_EMAIL">CONFIG_SMTP_SYSTEM_EMAIL</a></code></div>
<div class="col-last even-row-color"><code>"mail.smtp.system.email"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SMTP_TIMEOUT">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SMTP_TIMEOUT">CONFIG_SMTP_TIMEOUT</a></code></div>
<div class="col-last odd-row-color"><code>"mail.smtp.timeout"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SMTP_TIMEOUT_CON">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SMTP_TIMEOUT_CON">CONFIG_SMTP_TIMEOUT_CON</a></code></div>
<div class="col-last even-row-color"><code>"mail.smtp.connection.timeout"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SMTP_TLS">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SMTP_TLS">CONFIG_SMTP_TLS</a></code></div>
<div class="col-last odd-row-color"><code>"mail.smtp.starttls.enable"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_SMTP_USER">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_SMTP_USER">CONFIG_SMTP_USER</a></code></div>
<div class="col-last even-row-color"><code>"mail.smtp.user"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.CONFIG_THEME">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/openmeetings/util/OpenmeetingsVariables.html#CONFIG_THEME">CONFIG_THEME</a></code></div>
<div class="col-last odd-row-color"><code>"ui.theme"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.DEFAULT_APP_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/openmeetings/util/OpenmeetingsVariables.html#DEFAULT_APP_NAME">DEFAULT_APP_NAME</a></code></div>
<div class="col-last even-row-color"><code>"OpenMeetings"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.DEFAULT_BASE_URL">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/openmeetings/util/OpenmeetingsVariables.html#DEFAULT_BASE_URL">DEFAULT_BASE_URL</a></code></div>
<div class="col-last odd-row-color"><code>"https://localhost:5443/openmeetings/"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.DEFAULT_CONTEXT_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/openmeetings/util/OpenmeetingsVariables.html#DEFAULT_CONTEXT_NAME">DEFAULT_CONTEXT_NAME</a></code></div>
<div class="col-last even-row-color"><code>"openmeetings"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.DEFAULT_CSP_FONT">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/openmeetings/util/OpenmeetingsVariables.html#DEFAULT_CSP_FONT">DEFAULT_CSP_FONT</a></code></div>
<div class="col-last odd-row-color"><code>"https://fonts.gstatic.com"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.DEFAULT_MAX_UPLOAD_SIZE">public&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/util/OpenmeetingsVariables.html#DEFAULT_MAX_UPLOAD_SIZE">DEFAULT_MAX_UPLOAD_SIZE</a></code></div>
<div class="col-last even-row-color"><code>104857600L</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.DEFAULT_SIP_CONTEXT">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/openmeetings/util/OpenmeetingsVariables.html#DEFAULT_SIP_CONTEXT">DEFAULT_SIP_CONTEXT</a></code></div>
<div class="col-last odd-row-color"><code>"rooms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.PARAM_SRC">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/openmeetings/util/OpenmeetingsVariables.html#PARAM_SRC">PARAM_SRC</a></code></div>
<div class="col-last even-row-color"><code>"src"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.PARAM_SRC_UND">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/openmeetings/util/OpenmeetingsVariables.html#PARAM_SRC_UND">PARAM_SRC_UND</a></code></div>
<div class="col-last odd-row-color"><code>"_src"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.PARAM_STATUS">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/openmeetings/util/OpenmeetingsVariables.html#PARAM_STATUS">PARAM_STATUS</a></code></div>
<div class="col-last even-row-color"><code>"status"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.PARAM_USER_ID">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/openmeetings/util/OpenmeetingsVariables.html#PARAM_USER_ID">PARAM_USER_ID</a></code></div>
<div class="col-last odd-row-color"><code>"userId"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.RECENT_ROOMS_COUNT">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/util/OpenmeetingsVariables.html#RECENT_ROOMS_COUNT">RECENT_ROOMS_COUNT</a></code></div>
<div class="col-last even-row-color"><code>5</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.USER_LOGIN_MINIMUM_LENGTH">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/openmeetings/util/OpenmeetingsVariables.html#USER_LOGIN_MINIMUM_LENGTH">USER_LOGIN_MINIMUM_LENGTH</a></code></div>
<div class="col-last odd-row-color"><code>4</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.util.OpenmeetingsVariables.USER_PASSWORD_MINIMUM_LENGTH">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/util/OpenmeetingsVariables.html#USER_PASSWORD_MINIMUM_LENGTH">USER_PASSWORD_MINIMUM_LENGTH</a></code></div>
<div class="col-last even-row-color"><code>8</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.openmeetings.util.<a href="org/apache/openmeetings/util/XmlExport.html" title="class in org.apache.openmeetings.util">XmlExport</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.openmeetings.util.XmlExport.LICENSE">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/openmeetings/util/XmlExport.html#LICENSE">LICENSE</a></code></div>
<div class="col-last even-row-color"><code>"  Licensed to the Apache Software Foundation (ASF) under one\n  or more contributor license agreements.  See the NOTICE file\n  distributed with this work for additional information\n  regarding copyright ownership.  The ASF licenses this file\n  to you under the Apache License, Version 2.0 (the\n  \"License\"); you may not use this file except in compliance\n  with the License.  You may obtain a copy of the License at\n\n      http://www.apache.org/licenses/LICENSE-2.0\n\n  Unless required by applicable law or agreed to in writing,\n  software distributed under the License is distributed on an\n  \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n  KIND, either express or implied.  See the License for the\n  specific language governing permissions and limitations\n  under the License.\n"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.util.mail.<a href="org/apache/openmeetings/util/mail/MailUtil.html" title="class in org.apache.openmeetings.util.mail">MailUtil</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.openmeetings.util.mail.MailUtil.MAILTO">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/openmeetings/util/mail/MailUtil.html#MAILTO">MAILTO</a></code></div>
<div class="col-last even-row-color"><code>"mailto:"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.util.mail.MailUtil.SCHEME_MAILTO">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/openmeetings/util/mail/MailUtil.html#SCHEME_MAILTO">SCHEME_MAILTO</a></code></div>
<div class="col-last odd-row-color"><code>"mailto"</code></div>
</div>
</li>
</ul>
</section>
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2012&#x2013;2023 <a href="https://apache.org">Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
