// ---------------------------------------------------------------------------
// <copyright file="DatabaseConfig.g.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
//
// </copyright>
// ---------------------------------------------------------------------------

//    			  DO NOT EDIT THIS FILE DIRECTLY!
//
// This file is autogenerated from sysparam.xml using DatabaseConfig.xsl, with compatMode = ""
// To modify or add new params, make changes to sysparam.xml and then run gengen.bat to update the source files.

namespace Microsoft.Database.Isam.Config
{
    using System;
    using Microsoft.Isam.Esent.Interop;
    using Microsoft.Isam.Esent.Interop.Vista;
    using Microsoft.Isam.Esent.Interop.Windows7;
    using Microsoft.Isam.Esent.Interop.Windows8;
    using Microsoft.Isam.Esent.Interop.Windows81;

    /// <summary>
    /// A class that contains all engine wide Ese parameters.
    /// </summary>
    public partial class DatabaseConfig : ConfigSetBase
    {
        /// <summary>
        /// The exclusive upper bound on JET_param*.
        /// </summary>
        internal const int ParamMaxValueInvalid = 196; // should be equal to JET_paramMaxValueInvalid
    
        /// <summary>
        /// Fills the param table from auto-generated code.
        /// </summary>
        static partial void FillParamTable()
        {
            DatabaseConfig.ParamTable[0] = new ParamDef(0, false, typeof(string)); // JET_paramSystemPath
            DatabaseConfig.ParamTable[1] = new ParamDef(1, false, typeof(string)); // JET_paramTempPath
            DatabaseConfig.ParamTable[2] = new ParamDef(2, false, typeof(string)); // JET_paramLogFilePath
            DatabaseConfig.ParamTable[3] = new ParamDef(3, false, typeof(string)); // JET_paramBaseName
            DatabaseConfig.ParamTable[4] = new ParamDef(4, false, typeof(string)); // JET_paramEventSource
            DatabaseConfig.ParamTable[5] = new ParamDef(5, false, typeof(int)); // JET_paramMaxSessions
            DatabaseConfig.ParamTable[6] = new ParamDef(6, false, typeof(int)); // JET_paramMaxOpenTables
            DatabaseConfig.ParamTable[8] = new ParamDef(8, false, typeof(int)); // JET_paramMaxCursors
            DatabaseConfig.ParamTable[9] = new ParamDef(9, false, typeof(int)); // JET_paramMaxVerPages
            DatabaseConfig.ParamTable[10] = new ParamDef(10, false, typeof(int)); // JET_paramMaxTemporaryTables
            DatabaseConfig.ParamTable[11] = new ParamDef(11, false, typeof(int)); // JET_paramLogFileSize
            DatabaseConfig.ParamTable[12] = new ParamDef(12, false, typeof(int)); // JET_paramLogBuffers
            DatabaseConfig.ParamTable[16] = new ParamDef(16, false, typeof(CommitTransactionGrbit)); // JET_paramCommitDefault
            DatabaseConfig.ParamTable[17] = new ParamDef(17, false, typeof(bool)); // JET_paramCircularLog
            DatabaseConfig.ParamTable[18] = new ParamDef(18, false, typeof(int)); // JET_paramDbExtensionSize
            DatabaseConfig.ParamTable[19] = new ParamDef(19, false, typeof(int)); // JET_paramPageTempDBMin
            DatabaseConfig.ParamTable[20] = new ParamDef(20, false, typeof(int)); // JET_paramPageFragment
            DatabaseConfig.ParamTable[23] = new ParamDef(23, false, typeof(int)); // JET_paramCacheSizeMax
            DatabaseConfig.ParamTable[24] = new ParamDef(24, false, typeof(int)); // JET_paramCheckpointDepthMax
            DatabaseConfig.ParamTable[25] = new ParamDef(25, true, typeof(int)); // JET_paramLRUKCorrInterval
            DatabaseConfig.ParamTable[26] = new ParamDef(26, true, typeof(int)); // JET_paramLRUKHistoryMax
            DatabaseConfig.ParamTable[27] = new ParamDef(27, true, typeof(int)); // JET_paramLRUKPolicy
            DatabaseConfig.ParamTable[28] = new ParamDef(28, true, typeof(int)); // JET_paramLRUKTimeout
            DatabaseConfig.ParamTable[30] = new ParamDef(30, true, typeof(int)); // JET_paramOutstandingIOMax
            DatabaseConfig.ParamTable[31] = new ParamDef(31, false, typeof(int)); // JET_paramStartFlushThreshold
            DatabaseConfig.ParamTable[32] = new ParamDef(32, false, typeof(int)); // JET_paramStopFlushThreshold
            DatabaseConfig.ParamTable[34] = new ParamDef(34, false, typeof(string)); // JET_paramRecovery
            DatabaseConfig.ParamTable[35] = new ParamDef(35, false, typeof(int)); // JET_paramEnableOnlineDefrag
            DatabaseConfig.ParamTable[37] = new ParamDef(37, false, typeof(IntPtr)); // JET_paramPrintFunction
            DatabaseConfig.ParamTable[38] = new ParamDef(38, false, typeof(int)); // JET_paramTransactionLevel
            DatabaseConfig.ParamTable[39] = new ParamDef(39, false, typeof(int)); // JET_paramRFS2IOsPermitted
            DatabaseConfig.ParamTable[40] = new ParamDef(40, false, typeof(int)); // JET_paramRFS2AllocsPermitted
            DatabaseConfig.ParamTable[41] = new ParamDef(41, false, typeof(int)); // JET_paramCacheSize
            DatabaseConfig.ParamTable[42] = new ParamDef(42, false, typeof(int)); // JET_paramCacheRequests
            DatabaseConfig.ParamTable[43] = new ParamDef(43, false, typeof(int)); // JET_paramCacheHits
            DatabaseConfig.ParamTable[45] = new ParamDef(45, false, typeof(bool)); // JET_paramEnableIndexChecking
            DatabaseConfig.ParamTable[46] = new ParamDef(46, false, typeof(bool)); // JET_paramEnableTempTableVersioning
            DatabaseConfig.ParamTable[49] = new ParamDef(49, false, typeof(string)); // JET_paramEventSourceKey
            DatabaseConfig.ParamTable[50] = new ParamDef(50, false, typeof(bool)); // JET_paramNoInformationEvent
            DatabaseConfig.ParamTable[51] = new ParamDef(51, false, typeof(EventLoggingLevels)); // JET_paramEventLoggingLevel
            DatabaseConfig.ParamTable[52] = new ParamDef(52, false, typeof(bool)); // JET_paramDeleteOutOfRangeLogs
            DatabaseConfig.ParamTable[53] = new ParamDef(53, false, typeof(int)); // JET_paramAccessDeniedRetryPeriod
            DatabaseConfig.ParamTable[54] = new ParamDef(54, false, typeof(bool)); // JET_paramEnableIndexCleanup
            DatabaseConfig.ParamTable[60] = new ParamDef(60, false, typeof(int)); // JET_paramCacheSizeMin
            DatabaseConfig.ParamTable[63] = new ParamDef(63, false, typeof(int)); // JET_paramPreferredVerPages
            DatabaseConfig.ParamTable[64] = new ParamDef(64, true, typeof(int)); // JET_paramDatabasePageSize
            DatabaseConfig.ParamTable[65] = new ParamDef(65, false, typeof(bool)); // JET_paramDisableCallbacks
            DatabaseConfig.ParamTable[69] = new ParamDef(69, false, typeof(bool)); // JET_paramLogFileCreateAsynch
            DatabaseConfig.ParamTable[71] = new ParamDef(71, false, typeof(bool)); // JET_paramZeroDatabaseDuringBackup
            DatabaseConfig.ParamTable[72] = new ParamDef(72, false, typeof(JET_UNICODEINDEX)); // JET_paramUnicodeIndexDefault
            DatabaseConfig.ParamTable[73] = new ParamDef(73, false, typeof(IntPtr)); // JET_paramRuntimeCallback
            DatabaseConfig.ParamTable[77] = new ParamDef(77, false, typeof(bool)); // JET_paramCleanupMismatchedLogFiles
            DatabaseConfig.ParamTable[79] = new ParamDef(79, false, typeof(int)); // JET_paramRecoveryCurrentLogfile
            DatabaseConfig.ParamTable[81] = new ParamDef(81, true, typeof(int)); // JET_paramGlobalMinVerPages
            DatabaseConfig.ParamTable[82] = new ParamDef(82, false, typeof(int)); // JET_paramOSSnapshotTimeout
            DatabaseConfig.ParamTable[98] = new ParamDef(98, false, typeof(JET_ExceptionAction)); // JET_paramExceptionAction
            DatabaseConfig.ParamTable[99] = new ParamDef(99, true, typeof(int)); // JET_paramEventLogCache
            DatabaseConfig.ParamTable[100] = new ParamDef(100, false, typeof(bool)); // JET_paramCreatePathIfNotExist
            DatabaseConfig.ParamTable[101] = new ParamDef(101, true, typeof(int)); // JET_paramPageHintCacheSize
            DatabaseConfig.ParamTable[102] = new ParamDef(102, false, typeof(bool)); // JET_paramOneDatabasePerSession
            DatabaseConfig.ParamTable[104] = new ParamDef(104, true, typeof(int)); // JET_paramMaxInstances
            DatabaseConfig.ParamTable[105] = new ParamDef(105, false, typeof(int)); // JET_paramVersionStoreTaskQueueMax
            DatabaseConfig.ParamTable[107] = new ParamDef(107, true, typeof(bool)); // JET_paramDisablePerfmon
            DatabaseConfig.ParamTable[110] = new ParamDef(110, false, typeof(int)); // JET_paramIndexTuplesLengthMin
            DatabaseConfig.ParamTable[111] = new ParamDef(111, false, typeof(int)); // JET_paramIndexTuplesLengthMax
            DatabaseConfig.ParamTable[112] = new ParamDef(112, false, typeof(int)); // JET_paramIndexTuplesToIndexMax
            DatabaseConfig.ParamTable[113] = new ParamDef(113, false, typeof(string)); // JET_paramAlternateDatabaseRecoveryPath
            DatabaseConfig.ParamTable[125] = new ParamDef(125, false, typeof(int)); // JET_paramCachedClosedTables
            DatabaseConfig.ParamTable[126] = new ParamDef(126, true, typeof(bool)); // JET_paramEnableFileCache
            DatabaseConfig.ParamTable[127] = new ParamDef(127, true, typeof(bool)); // JET_paramEnableViewCache
            DatabaseConfig.ParamTable[128] = new ParamDef(128, true, typeof(int)); // JET_paramVerPageSize
            DatabaseConfig.ParamTable[129] = new ParamDef(129, false, typeof(int)); // JET_paramConfiguration
            DatabaseConfig.ParamTable[130] = new ParamDef(130, false, typeof(bool)); // JET_paramEnableAdvanced
            DatabaseConfig.ParamTable[131] = new ParamDef(131, false, typeof(int)); // JET_paramMaxColtyp
            DatabaseConfig.ParamTable[132] = new ParamDef(132, false, typeof(int)); // JET_paramIndexTupleIncrement
            DatabaseConfig.ParamTable[133] = new ParamDef(133, false, typeof(int)); // JET_paramIndexTupleStart
            DatabaseConfig.ParamTable[134] = new ParamDef(134, false, typeof(int)); // JET_paramKeyMost
            DatabaseConfig.ParamTable[135] = new ParamDef(135, false, typeof(int)); // JET_paramCheckpointIOMax
            DatabaseConfig.ParamTable[136] = new ParamDef(136, false, typeof(LegacyFileNames)); // JET_paramLegacyFileNames
            DatabaseConfig.ParamTable[137] = new ParamDef(137, true, typeof(string)); // JET_paramTableClass1Name
            DatabaseConfig.ParamTable[138] = new ParamDef(138, true, typeof(string)); // JET_paramTableClass2Name
            DatabaseConfig.ParamTable[139] = new ParamDef(139, true, typeof(string)); // JET_paramTableClass3Name
            DatabaseConfig.ParamTable[140] = new ParamDef(140, true, typeof(string)); // JET_paramTableClass4Name
            DatabaseConfig.ParamTable[141] = new ParamDef(141, true, typeof(string)); // JET_paramTableClass5Name
            DatabaseConfig.ParamTable[142] = new ParamDef(142, true, typeof(string)); // JET_paramTableClass6Name
            DatabaseConfig.ParamTable[143] = new ParamDef(143, true, typeof(string)); // JET_paramTableClass7Name
            DatabaseConfig.ParamTable[144] = new ParamDef(144, true, typeof(string)); // JET_paramTableClass8Name
            DatabaseConfig.ParamTable[145] = new ParamDef(145, true, typeof(string)); // JET_paramTableClass9Name
            DatabaseConfig.ParamTable[146] = new ParamDef(146, true, typeof(string)); // JET_paramTableClass10Name
            DatabaseConfig.ParamTable[147] = new ParamDef(147, true, typeof(string)); // JET_paramTableClass11Name
            DatabaseConfig.ParamTable[148] = new ParamDef(148, true, typeof(string)); // JET_paramTableClass12Name
            DatabaseConfig.ParamTable[149] = new ParamDef(149, true, typeof(string)); // JET_paramTableClass13Name
            DatabaseConfig.ParamTable[150] = new ParamDef(150, true, typeof(string)); // JET_paramTableClass14Name
            DatabaseConfig.ParamTable[151] = new ParamDef(151, true, typeof(string)); // JET_paramTableClass15Name
            DatabaseConfig.ParamTable[152] = new ParamDef(152, false, typeof(int)); // JET_paramIOPriority
            DatabaseConfig.ParamTable[153] = new ParamDef(153, false, typeof(int)); // JET_paramWaypointLatency
            DatabaseConfig.ParamTable[155] = new ParamDef(155, true, typeof(bool)); // JET_paramDisableBlockVerification
            DatabaseConfig.ParamTable[156] = new ParamDef(156, false, typeof(bool)); // JET_paramEnablePersistedCallbacks
            DatabaseConfig.ParamTable[158] = new ParamDef(158, false, typeof(int)); // JET_paramPeriodicLogRolloverLLR
            DatabaseConfig.ParamTable[160] = new ParamDef(160, false, typeof(bool)); // JET_paramDefragmentSequentialBTrees
            DatabaseConfig.ParamTable[161] = new ParamDef(161, false, typeof(int)); // JET_paramDefragmentSequentialBTreesDensityCheckFrequency
            DatabaseConfig.ParamTable[162] = new ParamDef(162, true, typeof(int)); // JET_paramIOThrottlingTimeQuanta
            DatabaseConfig.ParamTable[163] = new ParamDef(163, false, typeof(int)); // JET_paramLVChunkSizeMost
            DatabaseConfig.ParamTable[164] = new ParamDef(164, true, typeof(int)); // JET_paramMaxCoalesceReadSize
            DatabaseConfig.ParamTable[165] = new ParamDef(165, true, typeof(int)); // JET_paramMaxCoalesceWriteSize
            DatabaseConfig.ParamTable[166] = new ParamDef(166, true, typeof(int)); // JET_paramMaxCoalesceReadGapSize
            DatabaseConfig.ParamTable[167] = new ParamDef(167, true, typeof(int)); // JET_paramMaxCoalesceWriteGapSize
            DatabaseConfig.ParamTable[169] = new ParamDef(169, false, typeof(int)); // JET_paramEnableDBScanInRecovery
            DatabaseConfig.ParamTable[170] = new ParamDef(170, false, typeof(int)); // JET_paramDbScanThrottle
            DatabaseConfig.ParamTable[171] = new ParamDef(171, false, typeof(int)); // JET_paramDbScanIntervalMinSec
            DatabaseConfig.ParamTable[172] = new ParamDef(172, false, typeof(int)); // JET_paramDbScanIntervalMaxSec
            DatabaseConfig.ParamTable[177] = new ParamDef(177, false, typeof(int)); // JET_paramCachePriority
            DatabaseConfig.ParamTable[178] = new ParamDef(178, false, typeof(int)); // JET_paramMaxTransactionSize
            DatabaseConfig.ParamTable[179] = new ParamDef(179, false, typeof(int)); // JET_paramPrereadIOMax
            DatabaseConfig.ParamTable[180] = new ParamDef(180, false, typeof(bool)); // JET_paramEnableDBScanSerialization
            DatabaseConfig.ParamTable[181] = new ParamDef(181, true, typeof(int)); // JET_paramHungIOThreshold
            DatabaseConfig.ParamTable[182] = new ParamDef(182, true, typeof(int)); // JET_paramHungIOActions
            DatabaseConfig.ParamTable[183] = new ParamDef(183, true, typeof(int)); // JET_paramMinDataForXpress
            DatabaseConfig.ParamTable[184] = new ParamDef(184, false, typeof(ShrinkDatabaseGrbit)); // JET_paramEnableShrinkDatabase
            DatabaseConfig.ParamTable[186] = new ParamDef(186, true, typeof(string)); // JET_paramProcessFriendlyName
            DatabaseConfig.ParamTable[187] = new ParamDef(187, false, typeof(IntPtr)); // JET_paramDurableCommitCallback
            DatabaseConfig.ParamTable[189] = new ParamDef(189, false, typeof(string)); // JET_paramConfigStoreSpec
            DatabaseConfig.ParamTable[193] = new ParamDef(193, false, typeof(int)); // JET_paramPersistedLostFlushDetection
            DatabaseConfig.ParamTable[194] = new ParamDef(194, false, typeof(int)); // JET_paramEngineFormatVersion
        }

        /// <summary>
        /// This parameter indicates the relative or absolute file system path of the
        /// folder that will contain the checkpoint file for the instance. The path
        /// must be terminated with a backslash character, which indicates that the
        /// target path is a folder.
        /// </summary>
        public string SystemPath
        {
            get { return this.GetParam<string>(0); }
            set { this.SetParam(0, value); }
        }

        /// <summary>
        /// This parameter indicates the relative or absolute file system path of
        /// the folder or file that will contain the temporary database for the instance.
        /// If the path is to a folder that will contain the temporary database then it
        /// must be terminated with a backslash character.
        /// </summary>
        public string TempPath
        {
            get { return this.GetParam<string>(1); }
            set { this.SetParam(1, value); }
        }

        /// <summary>
        /// This parameter indicates the relative or absolute file system path of the
        /// folder that will contain the transaction logs for the instance. The path must
        /// be terminated with a backslash character, which indicates that the target path
        /// is a folder.
        /// </summary>
        public string LogFilePath
        {
            get { return this.GetParam<string>(2); }
            set { this.SetParam(2, value); }
        }

        /// <summary>
        /// This parameter sets the three letter prefix used for many of the files used by
        /// the database engine. For example, the checkpoint file is called EDB.CHK by
        /// default because EDB is the default base name.
        /// </summary>
        public string BaseName
        {
            get { return this.GetParam<string>(3); }
            set { this.SetParam(3, value); }
        }

        /// <summary>
        /// This parameter supplies an application specific string that will be added to
        /// any event log messages that are emitted by the database engine. This allows
        /// easy correlation of event log messages with the source application. By default
        /// the host application executable name will be used.
        /// </summary>
        public string EventSource
        {
            get { return this.GetParam<string>(4); }
            set { this.SetParam(4, value); }
        }

        /// <summary>
        /// This parameter reserves the requested number of session resources for use by an
        /// instance. A session resource directly corresponds to a JET_SESID data type.
        /// This setting will affect how many sessions can be used at the same time.
        /// </summary>
        public int MaxSessions
        {
            get { return this.GetParam<int>(5); }
            set { this.SetParam(5, value); }
        }

        /// <summary>
        /// This parameter reserves the requested number of B+ Tree resources for use by
        /// an instance. This setting will affect how many tables can be used at the same time.
        /// </summary>
        public int MaxOpenTables
        {
            get { return this.GetParam<int>(6); }
            set { this.SetParam(6, value); }
        }

        /// <summary>
        /// This parameter reserves the requested number of version store pages for use by an instance.
        /// </summary>
        public int MaxCursors
        {
            get { return this.GetParam<int>(8); }
            set { this.SetParam(8, value); }
        }

        /// <summary>
        /// This parameter reserves the requested number of version store pages for use by an instance.
        /// </summary>
        public int MaxVerPages
        {
            get { return this.GetParam<int>(9); }
            set { this.SetParam(9, value); }
        }

        /// <summary>
        /// This parameter reserves the requested number of temporary table resources for use
        /// by an instance. This setting will affect how many temporary tables can be used at
        /// the same time. If this system parameter is set to zero then no temporary database
        /// will be created and any activity that requires use of the temporary database will
        /// fail. This setting can be useful to avoid the I/O required to create the temporary
        /// database if it is known that it will not be used.
        /// </summary>
        /// <remarks>
        /// The use of a temporary table also requires a cursor resource.
        /// </remarks>
        public int MaxTemporaryTables
        {
            get { return this.GetParam<int>(10); }
            set { this.SetParam(10, value); }
        }

        /// <summary>
        /// This parameter will configure the size of the transaction log files. Each
        /// transaction log file is a fixed size. The size is equal to the setting of
        /// this system parameter in units of 1024 bytes.
        /// </summary>
        public int LogFileSize
        {
            get { return this.GetParam<int>(11); }
            set { this.SetParam(11, value); }
        }

        /// <summary>
        /// This parameter will configure the amount of memory used to cache log records
        /// before they are written to the transaction log file. The unit for this
        /// parameter is the sector size of the volume that holds the transaction log files.
        /// The sector size is almost always 512 bytes, so it is safe to assume that size
        /// for the unit. This parameter has an impact on performance. When the database
        /// engine is under heavy update load, this buffer can become full very rapidly.
        /// A larger cache size for the transaction log file is critical for good update
        /// performance under such a high load condition. The default is known to be too small
        /// for this case.
        /// Do not set this parameter to a number of buffers that is larger (in bytes) than
        /// half the size of a transaction log file.
        /// </summary>
        public int LogBuffers
        {
            get { return this.GetParam<int>(12); }
            set { this.SetParam(12, value); }
        }

        /// <summary>
        /// This parameter sets the default grbits for committing transactions.
        /// See <see cref="Api.JetCommitTransaction"/> and <see cref="Windows8Api.JetCommitTransaction2"/>L
        /// </summary>
        public CommitTransactionGrbit CommitDefault
        {
            get { return this.GetParam<CommitTransactionGrbit>(16); }
            set { this.SetParam(16, value); }
        }

        /// <summary>
        /// This parameter configures how transaction log files are managed by the database
        /// engine. When circular logging is off, all transaction log files that are generated
        /// are retained on disk until they are no longer needed because a full backup of the
        /// database has been performed. When circular logging is on, only transaction log files
        /// that are younger than the current checkpoint are retained on disk. The benefit of
        /// this mode is that backups are not required to retire old transaction log files.
        /// </summary>
        public bool CircularLog
        {
            get { return this.GetParam<bool>(17); }
            set { this.SetParam(17, value); }
        }

        /// <summary>
        /// This parameter controls the amount of space that is added to a database file each
        /// time it needs to grow to accommodate more data. The size is in database pages.
        /// </summary>
        public int DbExtensionSize
        {
            get { return this.GetParam<int>(18); }
            set { this.SetParam(18, value); }
        }

        /// <summary>
        /// This parameter controls the initial size of the temporary database. The size is in
        /// database pages. A size of zero indicates that the default size of an ordinary
        /// database should be used. It is often desirable for small applications to configure
        /// the temporary database to be as small as possible. Setting this parameter to
        /// SystemParameters.PageTempDBSmallest will achieve the smallest temporary database possible.
        /// </summary>
        public int PageTempDBMin
        {
            get { return this.GetParam<int>(19); }
            set { this.SetParam(19, value); }
        }

        /// <summary>
        /// Gets or sets PageFragment of type int
        /// </summary>
        public int PageFragment
        {
            get { return this.GetParam<int>(20); }
            set { this.SetParam(20, value); }
        }

        /// <summary>
        /// This parameter configures the maximum size of the database page cache. The size
        /// is in database pages. If this parameter is left to its default value, then the
        /// maximum size of the cache will be set to the size of physical memory when JetInit
        /// is called.
        /// </summary>
        public int CacheSizeMax
        {
            get { return this.GetParam<int>(23); }
            set { this.SetParam(23, value); }
        }

        /// <summary>
        /// This parameter controls how aggressively database pages are flushed from the
        /// database page cache to minimize the amount of time it will take to recover from a
        /// crash. The parameter is a threshold in bytes for about how many transaction log
        /// files will need to be replayed after a crash. If circular logging is enabled using
        /// JET_param.CircularLog then this parameter will also control the approximate amount
        /// of transaction log files that will be retained on disk.
        /// </summary>
        public int CheckpointDepthMax
        {
            get { return this.GetParam<int>(24); }
            set { this.SetParam(24, value); }
        }

        /// <summary>
        /// This parameter controls the correlation interval of ESE's LRU-K page replacement
        /// algorithm.
        /// </summary>
        public int LRUKCorrInterval
        {
            get { return this.GetParam<int>(25); }
            set { this.SetParam(25, value); }
        }

        /// <summary>
        /// Gets or sets LRUKHistoryMax of type int
        /// </summary>
        public int LRUKHistoryMax
        {
            get { return this.GetParam<int>(26); }
            set { this.SetParam(26, value); }
        }

        /// <summary>
        /// Gets or sets LRUKPolicy of type int
        /// </summary>
        public int LRUKPolicy
        {
            get { return this.GetParam<int>(27); }
            set { this.SetParam(27, value); }
        }

        /// <summary>
        /// This parameter controls the timeout interval of ESE's LRU-K page replacement
        /// algorithm.
        /// </summary>
        public int LRUKTimeout
        {
            get { return this.GetParam<int>(28); }
            set { this.SetParam(28, value); }
        }

        /// <summary>
        /// This parameter controls how many database file I/Os can be queued
        /// per-disk in the host operating system at one time. A larger value
        /// for this parameter can significantly help the performance of a large
        /// database application.
        /// </summary>
        public int OutstandingIOMax
        {
            get { return this.GetParam<int>(30); }
            set { this.SetParam(30, value); }
        }

        /// <summary>
        /// This parameter controls when the database page cache begins evicting pages from the
        /// cache to make room for pages that are not cached. When the number of page buffers in the cache
        /// drops below this threshold then a background process will be started to replenish that pool
        /// of available buffers. This threshold is always relative to the maximum cache size as set by
        /// JET_paramCacheSizeMax. This threshold must also always be less than the stop threshold as
        /// set by JET_paramStopFlushThreshold.
        /// <para>
        /// The distance height of the start threshold will determine the response time that the database
        /// page cache must have to produce available buffers before the application needs them. A high
        /// start threshold will give the background process more time to react. However, a high start
        /// threshold implies a higher stop threshold and that will reduce the effective size of the
        /// database page cache for modified pages (Windows 2000) or for all pages (Windows XP and later).
        /// </para>
        /// </summary>
        public int StartFlushThreshold
        {
            get { return this.GetParam<int>(31); }
            set { this.SetParam(31, value); }
        }

        /// <summary>
        /// This parameter controls when the database page cache ends evicting pages from the cache to make
        /// room for pages that are not cached. When the number of page buffers in the cache rises above
        /// this threshold then the background process that was started to replenish that pool of available
        /// buffers is stopped. This threshold is always relative to the maximum cache size as set by
        /// JET_paramCacheSizeMax. This threshold must also always be greater than the start threshold
        /// as set by JET_paramStartFlushThreshold.
        /// <para>
        /// The distance between the start threshold and the stop threshold affects the efficiency with
        /// which database pages are flushed by the background process. A larger gap will make it
        /// more likely that writes to neighboring pages may be combined. However, a high stop
        /// threshold will reduce the effective size of the database page cache for modified
        /// pages (Windows 2000) or for all pages (Windows XP and later).
        /// </para>
        /// </summary>
        public int StopFlushThreshold
        {
            get { return this.GetParam<int>(32); }
            set { this.SetParam(32, value); }
        }

        /// <summary>
        /// This parameter is the master switch that controls crash recovery for an instance.
        /// If this parameter is set to "On" then ARIES style recovery will be used to bring all
        /// databases in the instance to a consistent state in the event of a process or machine
        /// crash. If this parameter is set to "Off" then all databases in the instance will be
        /// managed without the benefit of crash recovery. That is to say, that if the instance
        /// is not shut down cleanly using JetTerm prior to the process exiting or machine shutdown
        /// then the contents of all databases in that instance will be corrupted.
        /// </summary>
        public string Recovery
        {
            get { return this.GetParam<string>(34); }
            set { this.SetParam(34, value); }
        }

        /// <summary>
        /// This parameter controls the behavior of online defragmentation when initiated using
        /// <see cref="Api.JetDefragment"/> and <see cref="Api.JetDefragment2"/>.
        /// </summary>
        public int EnableOnlineDefrag
        {
            get { return this.GetParam<int>(35); }
            set { this.SetParam(35, value); }
        }

        /// <summary>
        /// Gets PrintFunction of type IntPtr
        /// </summary>
        public IntPtr PrintFunction
        {
            get { return this.GetParam<IntPtr>(37); }
        }

        /// <summary>
        /// Gets TransactionLevel of type int
        /// </summary>
        public int TransactionLevel
        {
            get { return this.GetParam<int>(38); }
        }

        /// <summary>
        /// Gets or sets RFS2IOsPermitted of type int
        /// </summary>
        public int RFS2IOsPermitted
        {
            get { return this.GetParam<int>(39); }
            set { this.SetParam(39, value); }
        }

        /// <summary>
        /// Gets or sets RFS2AllocsPermitted of type int
        /// </summary>
        public int RFS2AllocsPermitted
        {
            get { return this.GetParam<int>(40); }
            set { this.SetParam(40, value); }
        }

        /// <summary>
        /// This parameter can be used to control the size of the database page cache at run time.
        /// Ordinarily, the cache will automatically tune its size as a function of database and
        /// machine activity levels. If the application sets this parameter to zero, then the cache
        /// will tune its own size in this manner. However, if the application sets this parameter
        /// to a non-zero value then the cache will adjust itself to that target size.
        /// </summary>
        public int CacheSize
        {
            get { return this.GetParam<int>(41); }
            set { this.SetParam(41, value); }
        }

        /// <summary>
        /// Gets CacheRequests of type int
        /// </summary>
        public int CacheRequests
        {
            get { return this.GetParam<int>(42); }
        }

        /// <summary>
        /// Gets CacheHits of type int
        /// </summary>
        public int CacheHits
        {
            get { return this.GetParam<int>(43); }
        }

        /// <summary>
        /// When this parameter is true, every database is checked at JetAttachDatabase time for
        /// indexes over Unicode key columns that were built using an older version of the NLS
        /// library in the operating system. This must be done because the database engine persists
        /// the sort keys generated by LCMapStringW and the value of these sort keys change from release to release.
        /// If a primary index is detected to be in this state then JetAttachDatabase will always fail with
        /// JET_err.PrimaryIndexCorrupted.
        /// If any secondary indexes are detected to be in this state then there are two possible outcomes.
        /// If AttachDatabaseGrbit.DeleteCorruptIndexes was passed to JetAttachDatabase then these indexes
        /// will be deleted and JET_wrnCorruptIndexDeleted will be returned from JetAttachDatabase. These
        /// indexes will need to be recreated by your application. If AttachDatabaseGrbit.DeleteCorruptIndexes
        /// was not passed to JetAttachDatabase then the call will fail with JET_errSecondaryIndexCorrupted.
        /// </summary>
        public bool EnableIndexChecking
        {
            get { return this.GetParam<bool>(45); }
            set { this.SetParam(45, value); }
        }

        /// <summary>
        /// Gets or sets EnableTempTableVersioning of type bool
        /// </summary>
        public bool EnableTempTableVersioning
        {
            get { return this.GetParam<bool>(46); }
            set { this.SetParam(46, value); }
        }

        /// <summary>
        /// This parameter can be used to control which event log the database engine uses for its event log
        /// messages. By default, all event log messages will go to the Application event log. If the registry
        /// key name for another event log is configured then the event log messages will go there instead.
        /// </summary>
        public string EventSourceKey
        {
            get { return this.GetParam<string>(49); }
            set { this.SetParam(49, value); }
        }

        /// <summary>
        /// When this parameter is true, informational event log messages that would ordinarily be generated by
        /// the database engine will be suppressed.
        /// </summary>
        public bool NoInformationEvent
        {
            get { return this.GetParam<bool>(50); }
            set { this.SetParam(50, value); }
        }

        /// <summary>
        /// Configures the detail level of eventlog messages that are emitted
        /// to the eventlog by the database engine. Higher numbers will result
        /// in more detailed eventlog messages.
        /// </summary>
        public EventLoggingLevels EventLoggingLevel
        {
            get { return this.GetParam<EventLoggingLevels>(51); }
            set { this.SetParam(51, value); }
        }

        /// <summary>
        /// Delete the log files that are not matching (generation wise) during soft recovery.
        /// </summary>
        public bool DeleteOutOfRangeLogs
        {
            get { return this.GetParam<bool>(52); }
            set { this.SetParam(52, value); }
        }

        /// <summary>
        /// Gets or sets AccessDeniedRetryPeriod of type int
        /// </summary>
        public int AccessDeniedRetryPeriod
        {
            get { return this.GetParam<int>(53); }
            set { this.SetParam(53, value); }
        }

        /// <summary>
        /// <para>
        /// After Windows 7, it was discovered that JET_paramEnableIndexCleanup had some implementation limitations, reducing its effectiveness.
        /// Rather than update it to work with locale names, the functionality is removed altogether.
        /// </para>
        /// <para>
        /// Unfortunately JET_paramEnableIndexCleanup can not be ignored altogether. JET_paramEnableIndexChecking defaults to false, so if
        /// JET_paramEnableIndexCleanup were to be removed entirely, then by default there were would be no checks for NLS changes!
        /// </para>
        /// <para>
        /// The current behavious (when enabled) is to track the language sort versions for the indices, and when the sort version for that
        /// particular locale changes, the engine knows which indices are now invalid. For example, if the sort version for only "de-de" changes,
        /// then the "de-de" indices are invalid, but the "en-us" indices will be fine.
        /// </para>
        /// <para>
        /// Post-Windows 8:
        /// JET_paramEnableIndexChecking accepts JET_INDEXCHECKING (which is an enum). The values of '0' and '1' have the same meaning as before,
        /// but '2' is JET_IndexCheckingDeferToOpenTable, which means that the NLS up-to-date-ness is NOT checked when the database is attached.
        /// It is deferred to JetOpenTable(), which may now fail with JET_errPrimaryIndexCorrupted or JET_errSecondaryIndexCorrupted (which
        /// are NOT actual corruptions, but instead reflect an NLS sort change).
        /// </para>
        /// <para>
        /// IN SUMMARY:
        /// New code should explicitly set both IndexChecking and IndexCleanup to the same value.
        /// </para>
        /// </summary>
        public bool EnableIndexCleanup
        {
            get { return this.GetParam<bool>(54); }
            set { this.SetParam(54, value); }
        }

        /// <summary>
        /// This parameter configures the minimum size of the database page cache. The size is in database pages.
        /// </summary>
        public int CacheSizeMin
        {
            get { return this.GetParam<int>(60); }
            set { this.SetParam(60, value); }
        }

        /// <summary>
        /// This parameter represents a threshold relative to <see cref="JET_param.MaxVerPages"/> that controls
        /// the discretionary use of version pages by the database engine. If the size of the version store exceeds
        /// this threshold then any information that is only used for optional background tasks, such as reclaiming
        /// deleted space in the database, is instead sacrificed to preserve room for transactional information.
        /// </summary>
        public int PreferredVerPages
        {
            get { return this.GetParam<int>(63); }
            set { this.SetParam(63, value); }
        }

        /// <summary>
        /// This parameter configures the page size for the database. The page
        /// size is the smallest unit of space allocation possible for a database
        /// file. The database page size is also very important because it sets
        /// the upper limit on the size of an individual record in the database.
        /// </summary>
        /// <remarks>
        /// Only one database page size is supported per process at this time.
        /// This means that if you are in a single process that contains different
        /// applications that use the database engine then they must all agree on
        /// a database page size.
        /// </remarks>
        public int DatabasePageSize
        {
            get { return this.GetParam<int>(64); }
            set { this.SetParam(64, value); }
        }

        /// <summary>
        /// Gets or sets DisableCallbacks of type bool
        /// </summary>
        public bool DisableCallbacks
        {
            get { return this.GetParam<bool>(65); }
            set { this.SetParam(65, value); }
        }

        /// <summary>
        /// Gets or sets LogFileCreateAsynch of type bool
        /// </summary>
        public bool LogFileCreateAsynch
        {
            get { return this.GetParam<bool>(69); }
            set { this.SetParam(69, value); }
        }

        /// <summary>
        /// Gets or sets ZeroDatabaseDuringBackup of type bool
        /// </summary>
        public bool ZeroDatabaseDuringBackup
        {
            get { return this.GetParam<bool>(71); }
            set { this.SetParam(71, value); }
        }

        /// <summary>
        /// This parameter configures the default LCMapString() lcid and flags to use for indexing unicode data.
        /// See <see cref="Windows8Api.JetCreateIndex4"/> for more details.
        /// </summary>
        public JET_UNICODEINDEX UnicodeIndexDefault
        {
            get { return this.GetParam<JET_UNICODEINDEX>(72); }
            set { this.SetParam(72, value); }
        }

#if !MANAGEDESENT_ON_WSA // Not exposed in MSDK
        /// <summary>
        /// Configures the engine with a <see cref="JET_CALLBACK"/> delegate.
        /// This callback may be called for the following reasons:
        /// <see cref="JET_cbtyp.FreeCursorLS"/>, <see cref="JET_cbtyp.FreeTableLS"/>
        /// or <see cref="JET_cbtyp.Null"/>. See <see cref="Api.JetSetLS"/>
        /// for more information. This parameter cannot currently be retrieved.
        /// </summary>
        public IntPtr RuntimeCallback
        {
            get { return this.GetParam<IntPtr>(73); }
            set { this.SetParam(73, value); }
        }
#endif

        /// <summary>
        /// This parameter controls the outcome of JetInit when the database
        /// engine is configured to start using transaction log files on disk
        /// that are of a different size than what is configured. Normally,
        /// <see cref="Api.JetInit"/> will successfully recover the databases
        /// but will fail with <see cref="JET_err.LogFileSizeMismatchDatabasesConsistent"/>
        /// to indicate that the log file size is misconfigured. However, when
        /// this parameter is set to true then the database engine will silently
        /// delete all the old log files, start a new set of transaction log files
        /// using the configured log file size. This parameter is useful when the
        /// application wishes to transparently change its transaction log file
        /// size yet still work transparently in upgrade and restore scenarios.
        /// </summary>
        public bool CleanupMismatchedLogFiles
        {
            get { return this.GetParam<bool>(77); }
            set { this.SetParam(77, value); }
        }

        /// <summary>
        /// Gets RecoveryCurrentLogfile of type int
        /// </summary>
        public int RecoveryCurrentLogfile
        {
            get { return this.GetParam<int>(79); }
        }

        /// <summary>
        /// Gets or sets GlobalMinVerPages of type int
        /// </summary>
        public int GlobalMinVerPages
        {
            get { return this.GetParam<int>(81); }
            set { this.SetParam(81, value); }
        }

        /// <summary>
        /// Gets or sets OSSnapshotTimeout of type int
        /// </summary>
        public int OSSnapshotTimeout
        {
            get { return this.GetParam<int>(82); }
            set { this.SetParam(82, value); }
        }

        /// <summary>
        /// This parameter controls what happens when an exception is thrown by the
        /// database engine or code that is called by the database engine. When set
        /// to JET_ExceptionMsgBox, any exception will be thrown to the Windows unhandled
        /// exception filter. This will result in the exception being handled as an
        /// application failure. The intent is to prevent application code from erroneously
        /// trying to catch and ignore an exception generated by the database engine.
        /// This cannot be allowed because database corruption could occur. If the application
        /// wishes to properly handle these exceptions then the protection can be disabled
        /// by setting this parameter to JET_ExceptionNone.
        /// </summary>
        public JET_ExceptionAction ExceptionAction
        {
            get { return this.GetParam<JET_ExceptionAction>(98); }
            set { this.SetParam(98, value); }
        }

        /// <summary>
        /// Gets or sets EventLogCache of type int
        /// </summary>
        public int EventLogCache
        {
            get { return this.GetParam<int>(99); }
            set { this.SetParam(99, value); }
        }

        /// <summary>
        /// When this parameter is set to true then any folder that is missing in a file system path in use by
        /// the database engine will be silently created. Otherwise, the operation that uses the missing file system
        /// path will fail with JET_err.InvalidPath.
        /// </summary>
        public bool CreatePathIfNotExist
        {
            get { return this.GetParam<bool>(100); }
            set { this.SetParam(100, value); }
        }

        /// <summary>
        /// Gets or sets PageHintCacheSize of type int
        /// </summary>
        public int PageHintCacheSize
        {
            get { return this.GetParam<int>(101); }
            set { this.SetParam(101, value); }
        }

        /// <summary>
        /// When this parameter is true then only one database is allowed to
        /// be opened using JetOpenDatabase by a given session at one time.
        /// The temporary database is excluded from this restriction.
        /// </summary>
        public bool OneDatabasePerSession
        {
            get { return this.GetParam<bool>(102); }
            set { this.SetParam(102, value); }
        }

        /// <summary>
        /// This parameter controls the maximum number of instances that can be created in a single process.
        /// </summary>
        public int MaxInstances
        {
            get { return this.GetParam<int>(104); }
            set { this.SetParam(104, value); }
        }

        /// <summary>
        /// This parameter controls the number of background cleanup work items that
        /// can be queued to the database engine thread pool at any one time.
        /// </summary>
        public int VersionStoreTaskQueueMax
        {
            get { return this.GetParam<int>(105); }
            set { this.SetParam(105, value); }
        }

        /// <summary>
        /// Gets or sets DisablePerfmon of type bool
        /// </summary>
        public bool DisablePerfmon
        {
            get { return this.GetParam<bool>(107); }
            set { this.SetParam(107, value); }
        }

        /// <summary>
        /// Gets or sets IndexTuplesLengthMin of type int
        /// </summary>
        public int IndexTuplesLengthMin
        {
            get { return this.GetParam<int>(110); }
            set { this.SetParam(110, value); }
        }

        /// <summary>
        /// Gets or sets IndexTuplesLengthMax of type int
        /// </summary>
        public int IndexTuplesLengthMax
        {
            get { return this.GetParam<int>(111); }
            set { this.SetParam(111, value); }
        }

        /// <summary>
        /// Gets or sets IndexTuplesToIndexMax of type int
        /// </summary>
        public int IndexTuplesToIndexMax
        {
            get { return this.GetParam<int>(112); }
            set { this.SetParam(112, value); }
        }

        /// <summary>
        /// The full path to each database is persisted in the transaction logs
        /// at run time. Ordinarily, these databases must remain at the original
        /// location for transaction replay to function correctly. This
        /// parameter can be used to force crash recovery or a restore operation
        /// to look for the databases referenced in the transaction log in the
        /// specified folder.
        /// </summary>
        public string AlternateDatabaseRecoveryPath
        {
            get { return this.GetParam<string>(113); }
            set { this.SetParam(113, value); }
        }

        /// <summary>
        /// This parameter controls the number of B+ Tree resources cached by
        /// the instance after the tables they represent have been closed by
        /// the application. Large values for this parameter will cause the
        /// database engine to use more memory but will increase the speed
        /// with which a large number of tables can be opened randomly by
        /// the application. This is useful for applications that have a
        /// schema with a very large number of tables.
        /// </summary>
        public int CachedClosedTables
        {
            get { return this.GetParam<int>(125); }
            set { this.SetParam(125, value); }
        }

        /// <summary>
        /// Enable the use of the OS file cache for all managed files.
        /// </summary>
        public bool EnableFileCache
        {
            get { return this.GetParam<bool>(126); }
            set { this.SetParam(126, value); }
        }

        /// <summary>
        /// Enable the use of memory mapped file I/O for database files.
        /// </summary>
        public bool EnableViewCache
        {
            get { return this.GetParam<bool>(127); }
            set { this.SetParam(127, value); }
        }

        /// <summary>
        /// This parameter sets the page size used by the version store.
        /// This page size is a runtime parameter and has no effect on the database format.
        /// </summary>
        public int VerPageSize
        {
            get { return this.GetParam<int>(128); }
            set { this.SetParam(128, value); }
        }

        /// <summary>
        /// This parameter exposes multiple sets of default values for the
        /// entire set of system parameters. When this parameter is set to
        /// a specific configuration, all system parameter values are reset
        /// to their default values for that configuration. If the
        /// configuration is set for a specific instance then global system
        /// parameters will not be reset to their default values.
        /// Small Configuration (0): The database engine is optimized for memory use.
        /// Legacy Configuration (1): The database engine has its traditional defaults.
        /// </summary>
        public int Configuration
        {
            get { return this.GetParam<int>(129); }
            set { this.SetParam(129, value); }
        }

        /// <summary>
        /// This parameter is used to control when the database engine accepts
        /// or rejects changes to a subset of the system parameters. This
        /// parameter is used in conjunction with ><see cref="Configuration"/> to
        /// prevent some system parameters from being set away from the selected
        /// configuration's defaults.
        /// </summary>
        public bool EnableAdvanced
        {
            get { return this.GetParam<bool>(130); }
            set { this.SetParam(130, value); }
        }

        /// <summary>
        /// Gets MaxColtyp of type int
        /// </summary>
        public int MaxColtyp
        {
            get { return this.GetParam<int>(131); }
        }

        /// <summary>
        /// Gets or sets IndexTupleIncrement of type int
        /// </summary>
        public int IndexTupleIncrement
        {
            get { return this.GetParam<int>(132); }
            set { this.SetParam(132, value); }
        }

        /// <summary>
        /// Gets or sets IndexTupleStart of type int
        /// </summary>
        public int IndexTupleStart
        {
            get { return this.GetParam<int>(133); }
            set { this.SetParam(133, value); }
        }

        /// <summary>
        /// This read-only parameter indicates the maximum allowable index key
        /// length that can be selected for the current database page size
        /// (as configured by <see cref="JET_param.DatabasePageSize"/>).
        /// </summary>
        public int KeyMost
        {
            get { return this.GetParam<int>(134); }
        }

        /// <summary>
        /// This parameter is used to control the maxiumum number of pending flush writes generated by checkpoint advancement.
        /// </summary>
        public int CheckpointIOMax
        {
            get { return this.GetParam<int>(135); }
            set { this.SetParam(135, value); }
        }

        /// <summary>
        /// This parameter provides backwards compatibility with the file naming conventions of earlier releases of the database engine.
        /// </summary>
        public LegacyFileNames LegacyFileNames
        {
            get { return this.GetParam<LegacyFileNames>(136); }
            set { this.SetParam(136, value); }
        }

        /// <summary>
        /// Set the name associated with table class 1.
        /// </summary>
        public string TableClass1Name
        {
            get { return this.GetParam<string>(137); }
            set { this.SetParam(137, value); }
        }

        /// <summary>
        /// Set the name associated with table class 2.
        /// </summary>
        public string TableClass2Name
        {
            get { return this.GetParam<string>(138); }
            set { this.SetParam(138, value); }
        }

        /// <summary>
        /// Set the name associated with table class 3.
        /// </summary>
        public string TableClass3Name
        {
            get { return this.GetParam<string>(139); }
            set { this.SetParam(139, value); }
        }

        /// <summary>
        /// Set the name associated with table class 4.
        /// </summary>
        public string TableClass4Name
        {
            get { return this.GetParam<string>(140); }
            set { this.SetParam(140, value); }
        }

        /// <summary>
        /// Set the name associated with table class 5.
        /// </summary>
        public string TableClass5Name
        {
            get { return this.GetParam<string>(141); }
            set { this.SetParam(141, value); }
        }

        /// <summary>
        /// Set the name associated with table class 6.
        /// </summary>
        public string TableClass6Name
        {
            get { return this.GetParam<string>(142); }
            set { this.SetParam(142, value); }
        }

        /// <summary>
        /// Set the name associated with table class 7.
        /// </summary>
        public string TableClass7Name
        {
            get { return this.GetParam<string>(143); }
            set { this.SetParam(143, value); }
        }

        /// <summary>
        /// Set the name associated with table class 8.
        /// </summary>
        public string TableClass8Name
        {
            get { return this.GetParam<string>(144); }
            set { this.SetParam(144, value); }
        }

        /// <summary>
        /// Set the name associated with table class 9.
        /// </summary>
        public string TableClass9Name
        {
            get { return this.GetParam<string>(145); }
            set { this.SetParam(145, value); }
        }

        /// <summary>
        /// Set the name associated with table class 10.
        /// </summary>
        public string TableClass10Name
        {
            get { return this.GetParam<string>(146); }
            set { this.SetParam(146, value); }
        }

        /// <summary>
        /// Set the name associated with table class 11.
        /// </summary>
        public string TableClass11Name
        {
            get { return this.GetParam<string>(147); }
            set { this.SetParam(147, value); }
        }

        /// <summary>
        /// Set the name associated with table class 12.
        /// </summary>
        public string TableClass12Name
        {
            get { return this.GetParam<string>(148); }
            set { this.SetParam(148, value); }
        }

        /// <summary>
        /// Set the name associated with table class 13.
        /// </summary>
        public string TableClass13Name
        {
            get { return this.GetParam<string>(149); }
            set { this.SetParam(149, value); }
        }

        /// <summary>
        /// Set the name associated with table class 14.
        /// </summary>
        public string TableClass14Name
        {
            get { return this.GetParam<string>(150); }
            set { this.SetParam(150, value); }
        }

        /// <summary>
        /// Set the name associated with table class 15.
        /// </summary>
        public string TableClass15Name
        {
            get { return this.GetParam<string>(151); }
            set { this.SetParam(151, value); }
        }

        /// <summary>
        /// Gets or sets IOPriority of type int
        /// </summary>
        public int IOPriority
        {
            get { return this.GetParam<int>(152); }
            set { this.SetParam(152, value); }
        }

        /// <summary>
        /// This parameter sets the number of logs that esent will defer database
        /// flushes for. This can be used to increase database recoverability if
        /// failures cause logfiles to be lost.
        /// </summary>
        public int WaypointLatency
        {
            get { return this.GetParam<int>(153); }
            set { this.SetParam(153, value); }
        }

        /// <summary>
        /// Gets or sets DisableBlockVerification of type bool
        /// </summary>
        public bool DisableBlockVerification
        {
            get { return this.GetParam<bool>(155); }
            set { this.SetParam(155, value); }
        }

        /// <summary>
        /// Gets or sets EnablePersistedCallbacks of type bool
        /// </summary>
        public bool EnablePersistedCallbacks
        {
            get { return this.GetParam<bool>(156); }
            set { this.SetParam(156, value); }
        }

        /// <summary>
        /// Gets or sets PeriodicLogRolloverLLR of type int
        /// </summary>
        public int PeriodicLogRolloverLLR
        {
            get { return this.GetParam<int>(158); }
            set { this.SetParam(158, value); }
        }

        /// <summary>
        /// Gets or sets DefragmentSequentialBTrees of type bool
        /// </summary>
        public bool DefragmentSequentialBTrees
        {
            get { return this.GetParam<bool>(160); }
            set { this.SetParam(160, value); }
        }

        /// <summary>
        /// Gets or sets DefragmentSequentialBTreesDensityCheckFrequency of type int
        /// </summary>
        public int DefragmentSequentialBTreesDensityCheckFrequency
        {
            get { return this.GetParam<int>(161); }
            set { this.SetParam(161, value); }
        }

        /// <summary>
        /// Gets or sets IOThrottlingTimeQuanta of type int
        /// </summary>
        public int IOThrottlingTimeQuanta
        {
            get { return this.GetParam<int>(162); }
            set { this.SetParam(162, value); }
        }

        /// <summary>
        /// This parameter is used to retrieve the chunk size of long-value
        /// (blob) data. Setting and retrieving data in multiples of this
        /// size increases efficiency.
        /// </summary>
        public int LVChunkSizeMost
        {
            get { return this.GetParam<int>(163); }
        }

        /// <summary>
        /// Maximum number of bytes that can be grouped for a coalesced read operation.
        /// </summary>
        /// <remarks>
        /// max = 10MB
        /// </remarks>
        public int MaxCoalesceReadSize
        {
            get { return this.GetParam<int>(164); }
            set { this.SetParam(164, value); }
        }

        /// <summary>
        /// Maximum number of bytes that can be grouped for a coalesced write operation.
        /// </summary>
        /// <remarks>
        /// max = 10MB
        /// </remarks>
        public int MaxCoalesceWriteSize
        {
            get { return this.GetParam<int>(165); }
            set { this.SetParam(165, value); }
        }

        /// <summary>
        /// Maximum number of bytes that can be gapped for a coalesced read operation.
        /// </summary>
        /// <remarks>
        /// max = 10MB
        /// </remarks>
        public int MaxCoalesceReadGapSize
        {
            get { return this.GetParam<int>(166); }
            set { this.SetParam(166, value); }
        }

        /// <summary>
        /// Maximum number of bytes that can be gapped for a coalesced write operation.
        /// </summary>
        /// <remarks>
        /// max = 10MB
        /// </remarks>
        public int MaxCoalesceWriteGapSize
        {
            get { return this.GetParam<int>(167); }
            set { this.SetParam(167, value); }
        }

        /// <summary>
        /// This parameter enables or disables Database Maintenance during recovery.
        /// </summary>
        public int EnableDBScanInRecovery
        {
            get { return this.GetParam<int>(169); }
            set { this.SetParam(169, value); }
        }

        /// <summary>
        /// This parameter sets the throttling interval for database scan, in milliseconds.
        /// </summary>
        public int DbScanThrottle
        {
            get { return this.GetParam<int>(170); }
            set { this.SetParam(170, value); }
        }

        /// <summary>
        /// The minimum amount of time to wait between two consecutive database scans.
        /// This parameter can be used to control how soon a database scan restarts after it has finished scanning the full database.
        /// </summary>
        /// <remarks>
        /// min = 0 sec, max = 3 weeks, default = 1 day
        /// </remarks>
        public int DbScanIntervalMinSec
        {
            get { return this.GetParam<int>(171); }
            set { this.SetParam(171, value); }
        }

        /// <summary>
        /// The maximum amount of time allowed between two consecutive database scans.
        /// This parameter can be used to control the maximum allowed time a database scan can take.
        /// The engine writes a warning message to the event log if a database scan can't finish in the specifed time.
        /// </summary>
        /// <remarks>
        /// min = 1 sec, max = 50 years, default = 1 week
        /// </remarks>
        public int DbScanIntervalMaxSec
        {
            get { return this.GetParam<int>(172); }
            set { this.SetParam(172, value); }
        }

        /// <summary>
        /// Per-instance property for relative cache priorities (default = 100).
        /// </summary>
        /// <remarks>
        /// min = 0, max = 1000, default = 100
        /// </remarks>
        public int CachePriority
        {
            get { return this.GetParam<int>(177); }
            set { this.SetParam(177, value); }
        }

        /// <summary>
        /// Percentage of version store that can be used by oldest transaction
        /// before <see cref="JET_err.VersionStoreOutOfMemory"/> (default = 100).
        /// </summary>
        /// <remarks>
        /// min = 0, max = 100, default = 100
        /// </remarks>
        public int MaxTransactionSize
        {
            get { return this.GetParam<int>(178); }
            set { this.SetParam(178, value); }
        }

        /// <summary>
        /// Maximum number of I/O operations dispatched for a given preread operation.
        /// </summary>
        /// <remarks>
        /// min = 0, max = 256, default = 8
        /// </remarks>
        public int PrereadIOMax
        {
            get { return this.GetParam<int>(179); }
            set { this.SetParam(179, value); }
        }

        /// <summary>
        /// Setting this parameter to true forces database maintenance/scan related IOs to be
        /// issued one at a time if they share the same disk.
        /// </summary>
        /// <remarks>
        /// default = false
        /// </remarks>
        public bool EnableDBScanSerialization
        {
            get { return this.GetParam<bool>(180); }
            set { this.SetParam(180, value); }
        }

        /// <summary>
        /// The threshold in milliseconds for what is considered a hung IO that should be acted upon.
        /// </summary>
        /// <remarks>
        /// min = 11 sec (see Reasonable Period in http://www.microsoft.com/whdc/driver/kernel/iocancel.mspx), max = 30 min, default = 30 seconds
        /// </remarks>
        public int HungIOThreshold
        {
            get { return this.GetParam<int>(181); }
            set { this.SetParam(181, value); }
        }

        /// <summary>
        /// A set of actions to be taken on IOs that appear hung.
        /// </summary>
        public int HungIOActions
        {
            get { return this.GetParam<int>(182); }
            set { this.SetParam(182, value); }
        }

        /// <summary>
        /// Smallest amount of data that should be compressed with xpress compression.
        /// </summary>
        public int MinDataForXpress
        {
            get { return this.GetParam<int>(183); }
            set { this.SetParam(183, value); }
        }

        /// <summary>
        /// Whether to free space back to the OS after deleting data. This may free space
        /// in the middle of files (done in the units of database extents). This uses Sparse Files,
        /// which is available on NTFS and ReFS (not FAT). The exact method of releasing space is an
        /// implementation detail and is subject to change.
        /// </summary>
        public ShrinkDatabaseGrbit EnableShrinkDatabase
        {
            get { return this.GetParam<ShrinkDatabaseGrbit>(184); }
            set { this.SetParam(184, value); }
        }

        /// <summary>
        /// Friendly name for this instance of the process.
        /// </summary>
        public string ProcessFriendlyName
        {
            get { return this.GetParam<string>(186); }
            set { this.SetParam(186, value); }
        }

        /// <summary>
        /// Callback for when log is flushed.
        /// </summary>
        public IntPtr DurableCommitCallback
        {
            get { return this.GetParam<IntPtr>(187); }
            set { this.SetParam(187, value); }
        }

        /// <summary>
        /// This allows the client to specify a registry path preceded by a reg: to optionally configure
        /// loading or overriding parameters from the registry.
        /// </summary>
        public string ConfigStoreSpec
        {
            get { return this.GetParam<string>(189); }
            set { this.SetParam(189, value); }
        }

        /// <summary>
        /// Configures persisted lost flush detection for databases while attached to an instance.
        /// </summary>
        public int PersistedLostFlushDetection
        {
            get { return this.GetParam<int>(193); }
            set { this.SetParam(193, value); }
        }

        /// <summary>
        /// Engine format version - specifies the maximum format version the engine should allow, ensuring no format features are used beyond this (allowing the DB / logs to be forward compatible).
        /// </summary>
        /// <remarks>
        /// Note: It is generally expected that most consumers will for simplicity set this even before the
        /// JetInit call to affect both log and database formats.
        /// However to support some complex consumer scenarios, while this param may seem like it can be set
        /// after instance init / JetInit(), we actually maintain a slight more complicated lifecycle. We
        /// allow it to be set after inst init as long as there are zero attached databases.
        /// </remarks>
        public int EngineFormatVersion
        {
            get { return this.GetParam<int>(194); }
            set { this.SetParam(194, value); }
        }

    }
}