<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Constant Field Values (Openmeetings DB 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.db.bind">
<h2 title="org.apache">org.apache.*</h2>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.bind.<a href="org/apache/openmeetings/db/bind/Constants.html" title="class in org.apache.openmeetings.db.bind">Constants</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.db.bind.Constants.APPOINTMENT_LIST_NODE">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/db/bind/Constants.html#APPOINTMENT_LIST_NODE">APPOINTMENT_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"appointments"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.APPOINTMENT_NODE">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/db/bind/Constants.html#APPOINTMENT_NODE">APPOINTMENT_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"appointment"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.CALENDAR_LIST_NODE">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/db/bind/Constants.html#CALENDAR_LIST_NODE">CALENDAR_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"calendars"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.CALENDAR_NODE">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/db/bind/Constants.html#CALENDAR_NODE">CALENDAR_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"calendar"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.CFG_LIST_NODE">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/db/bind/Constants.html#CFG_LIST_NODE">CFG_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"configs"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.CFG_NODE">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/db/bind/Constants.html#CFG_NODE">CFG_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"config"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.CHAT_LIST_NODE">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/db/bind/Constants.html#CHAT_LIST_NODE">CHAT_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"chat_messages"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.CHAT_NODE">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/db/bind/Constants.html#CHAT_NODE">CHAT_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"ChatMessage"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.CONTACT_LIST_NODE">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/db/bind/Constants.html#CONTACT_LIST_NODE">CONTACT_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"usercontacts"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.CONTACT_NODE">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/db/bind/Constants.html#CONTACT_NODE">CONTACT_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"usercontact"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.EXTRA_MENU_LIST_NODE">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/db/bind/Constants.html#EXTRA_MENU_LIST_NODE">EXTRA_MENU_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"ExtraMenus"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.EXTRA_MENU_NODE">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/db/bind/Constants.html#EXTRA_MENU_NODE">EXTRA_MENU_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"ExtraMenu"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.FILE_LIST_NODE">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/db/bind/Constants.html#FILE_LIST_NODE">FILE_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"fileExplorerItems"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.FILE_NODE">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/db/bind/Constants.html#FILE_NODE">FILE_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"fileItem"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.GROUP_LIST_NODE">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/db/bind/Constants.html#GROUP_LIST_NODE">GROUP_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"organisations"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.GROUP_NODE">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/db/bind/Constants.html#GROUP_NODE">GROUP_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"organisation"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.LDAP_LIST_NODE">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/db/bind/Constants.html#LDAP_LIST_NODE">LDAP_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"ldapconfigs"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.LDAP_NODE">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/db/bind/Constants.html#LDAP_NODE">LDAP_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"ldapconfig"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.MMEMBER_LIST_NODE">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/db/bind/Constants.html#MMEMBER_LIST_NODE">MMEMBER_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"meetingmembers"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.MMEMBER_NODE">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/db/bind/Constants.html#MMEMBER_NODE">MMEMBER_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"meetingmember"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.MSG_FOLDER_LIST_NODE">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/db/bind/Constants.html#MSG_FOLDER_LIST_NODE">MSG_FOLDER_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"privatemessagefolders"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.MSG_FOLDER_NODE">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/db/bind/Constants.html#MSG_FOLDER_NODE">MSG_FOLDER_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"privatemessagefolder"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.MSG_LIST_NODE">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/db/bind/Constants.html#MSG_LIST_NODE">MSG_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"privatemessages"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.MSG_NODE">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/db/bind/Constants.html#MSG_NODE">MSG_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"privatemessage"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.OAUTH_LIST_NODE">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/db/bind/Constants.html#OAUTH_LIST_NODE">OAUTH_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"oauth2servers"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.OAUTH_NODE">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/db/bind/Constants.html#OAUTH_NODE">OAUTH_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"OAuthServer"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.POLL_LIST_NODE">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/db/bind/Constants.html#POLL_LIST_NODE">POLL_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"roompolls"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.POLL_NODE">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/db/bind/Constants.html#POLL_NODE">POLL_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"roompoll"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.RECORDING_LIST_NODE">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/db/bind/Constants.html#RECORDING_LIST_NODE">RECORDING_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"flvrecordings"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.RECORDING_NODE">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/db/bind/Constants.html#RECORDING_NODE">RECORDING_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"flvrecording"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.ROOM_FILE_LIST_NODE">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/db/bind/Constants.html#ROOM_FILE_LIST_NODE">ROOM_FILE_LIST_NODE</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.db.bind.Constants.ROOM_FILE_NODE">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/db/bind/Constants.html#ROOM_FILE_NODE">ROOM_FILE_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"RoomFile"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.ROOM_GRP_LIST_NODE">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/db/bind/Constants.html#ROOM_GRP_LIST_NODE">ROOM_GRP_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"room_organisations"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.ROOM_GRP_NODE">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/db/bind/Constants.html#ROOM_GRP_NODE">ROOM_GRP_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"room_organisation"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.ROOM_LIST_NODE">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/db/bind/Constants.html#ROOM_LIST_NODE">ROOM_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"rooms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.ROOM_NODE">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/db/bind/Constants.html#ROOM_NODE">ROOM_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"room"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.USER_LIST_NODE">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/db/bind/Constants.html#USER_LIST_NODE">USER_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"users"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.USER_NODE">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/db/bind/Constants.html#USER_NODE">USER_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"user"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.bind.Constants.VERSION_LIST_NODE">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/db/bind/Constants.html#VERSION_LIST_NODE">VERSION_LIST_NODE</a></code></div>
<div class="col-last even-row-color"><code>"version"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.bind.Constants.VERSION_NODE">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/db/bind/Constants.html#VERSION_NODE">VERSION_NODE</a></code></div>
<div class="col-last odd-row-color"><code>"version"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.dao.label.<a href="org/apache/openmeetings/db/dao/label/LabelDao.html" title="class in org.apache.openmeetings.db.dao.label">LabelDao</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.db.dao.label.LabelDao.APP_RESOURCES_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/db/dao/label/LabelDao.html#APP_RESOURCES_PREFIX">APP_RESOURCES_PREFIX</a></code></div>
<div class="col-last even-row-color"><code>"Application"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.dao.label.LabelDao.APP_RESOURCES_SUFFIX">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/db/dao/label/LabelDao.html#APP_RESOURCES_SUFFIX">APP_RESOURCES_SUFFIX</a></code></div>
<div class="col-last odd-row-color"><code>".properties.xml"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.dao.label.LabelDao.ENTRY_ELEMENT">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/db/dao/label/LabelDao.html#ENTRY_ELEMENT">ENTRY_ELEMENT</a></code></div>
<div class="col-last even-row-color"><code>"entry"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.dao.label.LabelDao.KEY_ATTR">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/db/dao/label/LabelDao.html#KEY_ATTR">KEY_ATTR</a></code></div>
<div class="col-last odd-row-color"><code>"key"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.dao.room.<a href="org/apache/openmeetings/db/dao/room/RoomDao.html" title="class in org.apache.openmeetings.db.dao.room">RoomDao</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.db.dao.room.RoomDao.GRP_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/db/dao/room/RoomDao.html#GRP_FILES">GRP_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.db.dao.room.RoomDao.GRP_GROUPS">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/db/dao/room/RoomDao.html#GRP_GROUPS">GRP_GROUPS</a></code></div>
<div class="col-last odd-row-color"><code>"roomGroups"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.dao.room.RoomDao.GRP_MODERATORS">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/db/dao/room/RoomDao.html#GRP_MODERATORS">GRP_MODERATORS</a></code></div>
<div class="col-last even-row-color"><code>"roomModerators"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.dao.user.<a href="org/apache/openmeetings/db/dao/user/UserDao.html" title="class in org.apache.openmeetings.db.dao.user">UserDao</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.db.dao.user.UserDao.FETCH_GROUP_BACKUP">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/db/dao/user/UserDao.html#FETCH_GROUP_BACKUP">FETCH_GROUP_BACKUP</a></code></div>
<div class="col-last even-row-color"><code>"Backup_Export"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.dao.user.UserDao.FETCH_GROUP_GROUP">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/db/dao/user/UserDao.html#FETCH_GROUP_GROUP">FETCH_GROUP_GROUP</a></code></div>
<div class="col-last odd-row-color"><code>"Group_Users"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.dto.room.<a href="org/apache/openmeetings/db/dto/room/Whiteboard.html" title="class in org.apache.openmeetings.db.dto.room">Whiteboard</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.db.dto.room.Whiteboard.ATTR_FILE_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/db/dto/room/Whiteboard.html#ATTR_FILE_ID">ATTR_FILE_ID</a></code></div>
<div class="col-last even-row-color"><code>"fileId"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.dto.room.Whiteboard.ATTR_FILE_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/db/dto/room/Whiteboard.html#ATTR_FILE_TYPE">ATTR_FILE_TYPE</a></code></div>
<div class="col-last odd-row-color"><code>"fileType"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.dto.room.Whiteboard.ATTR_HEIGHT">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/db/dto/room/Whiteboard.html#ATTR_HEIGHT">ATTR_HEIGHT</a></code></div>
<div class="col-last even-row-color"><code>"height"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.dto.room.Whiteboard.ATTR_OMTYPE">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/db/dto/room/Whiteboard.html#ATTR_OMTYPE">ATTR_OMTYPE</a></code></div>
<div class="col-last odd-row-color"><code>"omType"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.dto.room.Whiteboard.ATTR_SLIDE">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/db/dto/room/Whiteboard.html#ATTR_SLIDE">ATTR_SLIDE</a></code></div>
<div class="col-last even-row-color"><code>"slide"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.dto.room.Whiteboard.ATTR_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/db/dto/room/Whiteboard.html#ATTR_TYPE">ATTR_TYPE</a></code></div>
<div class="col-last odd-row-color"><code>"type"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.dto.room.Whiteboard.ATTR_WIDTH">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/db/dto/room/Whiteboard.html#ATTR_WIDTH">ATTR_WIDTH</a></code></div>
<div class="col-last even-row-color"><code>"width"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.dto.room.Whiteboard.ATTR_ZOOM">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/db/dto/room/Whiteboard.html#ATTR_ZOOM">ATTR_ZOOM</a></code></div>
<div class="col-last odd-row-color"><code>"zoom"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.dto.room.Whiteboard.ITEMS_KEY">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/db/dto/room/Whiteboard.html#ITEMS_KEY">ITEMS_KEY</a></code></div>
<div class="col-last even-row-color"><code>"roomItems"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.dto.user.<a href="org/apache/openmeetings/db/dto/user/OAuthUser.html" title="class in org.apache.openmeetings.db.dto.user">OAuthUser</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.db.dto.user.OAuthUser.PARAM_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/db/dto/user/OAuthUser.html#PARAM_EMAIL">PARAM_EMAIL</a></code></div>
<div class="col-last even-row-color"><code>"address.email"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.dto.user.OAuthUser.PARAM_FNAME">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/db/dto/user/OAuthUser.html#PARAM_FNAME">PARAM_FNAME</a></code></div>
<div class="col-last odd-row-color"><code>"firstname"</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.dto.user.OAuthUser.PARAM_LNAME">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/db/dto/user/OAuthUser.html#PARAM_LNAME">PARAM_LNAME</a></code></div>
<div class="col-last even-row-color"><code>"lastname"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.dto.user.OAuthUser.PARAM_LOGIN">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/db/dto/user/OAuthUser.html#PARAM_LOGIN">PARAM_LOGIN</a></code></div>
<div class="col-last odd-row-color"><code>"login"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.entity.calendar.<a href="org/apache/openmeetings/db/entity/calendar/Appointment.html" title="class in org.apache.openmeetings.db.entity.calendar">Appointment</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.db.entity.calendar.Appointment.REMINDER_EMAIL_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/db/entity/calendar/Appointment.html#REMINDER_EMAIL_ID">REMINDER_EMAIL_ID</a></code></div>
<div class="col-last even-row-color"><code>2</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.entity.calendar.Appointment.REMINDER_ICAL_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/openmeetings/db/entity/calendar/Appointment.html#REMINDER_ICAL_ID">REMINDER_ICAL_ID</a></code></div>
<div class="col-last odd-row-color"><code>3</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.entity.calendar.Appointment.REMINDER_NONE_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/db/entity/calendar/Appointment.html#REMINDER_NONE_ID">REMINDER_NONE_ID</a></code></div>
<div class="col-last even-row-color"><code>1</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.entity.file.<a href="org/apache/openmeetings/db/entity/file/FileItemLog.html" title="class in org.apache.openmeetings.db.entity.file">FileItemLog</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.db.entity.file.FileItemLog.MAX_LOG_SIZE">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/db/entity/file/FileItemLog.html#MAX_LOG_SIZE">MAX_LOG_SIZE</a></code></div>
<div class="col-last even-row-color"><code>1048576</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.entity.room.<a href="org/apache/openmeetings/db/entity/room/Room.html" title="class in org.apache.openmeetings.db.entity.room">Room</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.db.entity.room.Room.CONFERENCE_TYPE_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/db/entity/room/Room.html#CONFERENCE_TYPE_ID">CONFERENCE_TYPE_ID</a></code></div>
<div class="col-last even-row-color"><code>1</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.entity.room.Room.INTERVIEW_TYPE_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/openmeetings/db/entity/room/Room.html#INTERVIEW_TYPE_ID">INTERVIEW_TYPE_ID</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.db.entity.room.Room.PRESENTATION_TYPE_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/db/entity/room/Room.html#PRESENTATION_TYPE_ID">PRESENTATION_TYPE_ID</a></code></div>
<div class="col-last even-row-color"><code>3</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.openmeetings.db.entity.room.<a href="org/apache/openmeetings/db/entity/room/RoomPoll.html" title="class in org.apache.openmeetings.db.entity.room">RoomPoll</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.db.entity.room.RoomPoll.NUMERIC_TYPE_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/db/entity/room/RoomPoll.html#NUMERIC_TYPE_ID">NUMERIC_TYPE_ID</a></code></div>
<div class="col-last even-row-color"><code>2</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.entity.room.RoomPoll.YES_NO_TYPE_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/openmeetings/db/entity/room/RoomPoll.html#YES_NO_TYPE_ID">YES_NO_TYPE_ID</a></code></div>
<div class="col-last odd-row-color"><code>1</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.entity.user.<a href="org/apache/openmeetings/db/entity/user/User.html" title="class in org.apache.openmeetings.db.entity.user">User</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.db.entity.user.User.DISPLAY_NAME_NA">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/db/entity/user/User.html#DISPLAY_NAME_NA">DISPLAY_NAME_NA</a></code></div>
<div class="col-last even-row-color"><code>"N/A"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.entity.user.User.SALUTATION_DR_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/openmeetings/db/entity/user/User.html#SALUTATION_DR_ID">SALUTATION_DR_ID</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.db.entity.user.User.SALUTATION_MR_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/db/entity/user/User.html#SALUTATION_MR_ID">SALUTATION_MR_ID</a></code></div>
<div class="col-last even-row-color"><code>1</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.entity.user.User.SALUTATION_MRS_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/openmeetings/db/entity/user/User.html#SALUTATION_MRS_ID">SALUTATION_MRS_ID</a></code></div>
<div class="col-last odd-row-color"><code>3</code></div>
<div class="col-first even-row-color"><code id="org.apache.openmeetings.db.entity.user.User.SALUTATION_MS_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/openmeetings/db/entity/user/User.html#SALUTATION_MS_ID">SALUTATION_MS_ID</a></code></div>
<div class="col-last even-row-color"><code>2</code></div>
<div class="col-first odd-row-color"><code id="org.apache.openmeetings.db.entity.user.User.SALUTATION_PROF_ID">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/openmeetings/db/entity/user/User.html#SALUTATION_PROF_ID">SALUTATION_PROF_ID</a></code></div>
<div class="col-last odd-row-color"><code>5</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.openmeetings.db.manager.<a href="org/apache/openmeetings/db/manager/ISipManager.html" title="interface in org.apache.openmeetings.db.manager">ISipManager</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.db.manager.ISipManager.SIP_FIRST_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/db/manager/ISipManager.html#SIP_FIRST_NAME">SIP_FIRST_NAME</a></code></div>
<div class="col-last even-row-color"><code>"SIP Transport"</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>
