class basswrapper {
/**
 * @param {string} wrapperPath path of the wrapper and addons 
 */
    constructor(wrapperPath) {
        let rootPath=process.cwd();
        let fs=require('fs');
        let dirname="";
        let path = require('path');

        let libPath = `${process.platform}-${process.arch}`;
        let basePath= path.join(rootPath, "libbass", libPath);

        if (wrapperPath==null){
            if(fs.existsSync(basePath)){
                dirname=basePath;
            }else{
                dirname=wrapperPath
            }
        }

        this.basswrapper = require(path.join(dirname, 'basswrapper.node'));
        this.basswrapper.InitLibrary(dirname + path.sep);

        //attributes
        this.BASS_SAMPLE_DEFAULT = this.basswrapper.BASS_SAMPLE_DEFAULT;
        this.BASS_3DALG_DEFAULT = this.basswrapper.BASS_3DALG_DEFAULT; // The default algorithm. If the user has selected a surround sound speaker configuration (eg. 4 or 5.1) in the control panel, the sound is panned among the available directional speakers. Otherwise it equates to BASS_3DALG_OFF.
        this.BASS_3DALG_FULL = this.basswrapper.BASS_3DALG_FULL; // This algorithm gives the highest quality 3D audio effect, but uses more CPU. This algorithm requires WDM drivers, if it's not available then BASS_3DALG_OFF will automatically be used instead.
        this.BASS_3DALG_LIGHT = this.basswrapper.BASS_3DALG_LIGHT; // This algorithm gives a good 3D audio effect, and uses less CPU than the FULL algorithm. This algorithm also requires WDM drivers, if it's not available then BASS_3DALG_OFF will automatically be used instead.
        this.BASS_3DALG_OFF = this.basswrapper.BASS_3DALG_OFF; // Uses normal left and right panning. The vertical axis is ignored except for scaling of volume due to distance. Doppler shift and volume scaling are still applied, but the 3D filtering is not performed. This is the most CPU efficient algorithm, but provides no virtual 3D audio effect. Head Related Transfer Function processing will not be done. Since only normal stereo panning is used, a channel using this algorithm may be accelerated by a 2D hardware voice if no free 3D hardware voices are available.
        this.BASS_3DMODE_NORMAL = this.basswrapper.BASS_3DMODE_NORMAL; // Normal 3D processing.
        this.BASS_3DMODE_OFF = this.basswrapper.BASS_3DMODE_OFF; // Turn off 3D processing on the channel, the sound will be played in the centre.
        this.BASS_3DMODE_RELATIVE = this.basswrapper.BASS_3DMODE_RELATIVE; // The channel's 3D position (position/velocity/orientation) is relative to the listener. When the listener's position/velocity/orientation is changed with BASS_Set3DPosition, the channel's position relative to the listener does not change.
        this.BASS_ACM_CHANS = this.basswrapper.BASS_ACM_CHANS;  // Only include formats with the same number of channels (mono/stereo) as the source.
        this.BASS_ACM_DEFAULT = this.basswrapper.BASS_ACM_DEFAULT; // Use the format buffer (form) contents as the default choice in the selector.
        this.BASS_ACM_RATE = this.basswrapper.BASS_ACM_RATE; // Only include formats with the same sample rate as the source.
        this.BASS_ACM_SUGGEST = this.basswrapper.BASS_ACM_SUGGEST; // Suggest a format without letting the user choose.
        this.BASS_ASYNCFILE = this.basswrapper.BASS_ASYNCFILE; // The file is read asynchronously. (HSTREAM)
        this.BASS_ATTRIB_CPU = this.basswrapper.BASS_ATTRIB_CPU; // Cpu usage of a channel.
        
        // Config
        this.BASS_CONFIG_NET_BUFFER = this.basswrapper.BASS_CONFIG_NET_BUFFER; 
        this.BASS_CONFIG_NET_PASSIVE = this.basswrapper.BASS_CONFIG_NET_PASSIVE; // Use passive mode in FTP connections?
        this.BASS_CONFIG_NET_PLAYLIST = this.basswrapper.BASS_CONFIG_NET_PLAYLIST; // Process URLs in PLS and M3U playlists?
        this.BASS_CONFIG_NET_PREBUF = this.basswrapper.BASS_CONFIG_NET_PREBUF; // Amount to pre-buffer before playing internet streams.
        this.BASS_CONFIG_NET_PROXY = this.basswrapper.BASS_CONFIG_NET_PROXY;
        this.BASS_CONFIG_NET_READTIMEOUT = this.basswrapper.BASS_CONFIG_NET_READTIMEOUT;
        this.BASS_CONFIG_NET_TIMEOUT = this.basswrapper.BASS_CONFIG_NET_TIMEOUT; // When playlist processing is enabled via the BASS_CONFIG_NET_PLAYLIST option, the timeout applies to each playlist entry rather than the playlist as a whole. in milliseconds
        this.BASS_CONFIG_OGG_PRESCAN = this.basswrapper.BASS_CONFIG_OGG_PRESCAN; // If TRUE, chained OGG files are pre-scanned.
        this.BASS_CONFIG_PAUSE_NOPLAY = this.basswrapper.BASS_CONFIG_PAUSE_NOPLAY; // Prevent channels being played while the output is paused?
        this.BASS_CONFIG_REC_BUFFER = this.basswrapper.BASS_CONFIG_REC_BUFFER; // The buffer length for recording channels.
        this.BASS_CONFIG_SPLIT_BUFFER = this.basswrapper.BASS_CONFIG_SPLIT_BUFFER; // When a source has its first splitter stream created, a buffer is allocated to hold its sample data, which all of its subsequently created splitter streams will share. This config option determines how big that buffer is. The default is 2000ms.
        this.BASS_CONFIG_SRC = this.basswrapper.BASS_CONFIG_SRC; // The default sample rate conversion quality.
        this.BASS_CONFIG_SRC_SAMPLE = this.basswrapper.BASS_CONFIG_SRC_SAMPLE; // The sample rate conversion quality... 0 = linear interpolation, 1 = 8 point sinc interpolation, 2 = 16 point sinc interpolation, 3 = 32 point sinc interpolation. Other values are also accepted.
        this.BASS_CONFIG_UNICODE = this.basswrapper.BASS_CONFIG_UNICODE; // If TRUE, device information will be in UTF-8 form. Otherwise it will be ANSI.
        this.BASS_CONFIG_UPDATEPERIOD = this.basswrapper.BASS_CONFIG_UPDATEPERIOD; // The update period in milliseconds... 0 = disable automatic updating. The minimum period is 5ms, the maximum is 100ms. If the period specified is outside this range, it is automatically capped.
        this.BASS_CONFIG_UPDATETHREADS = this.basswrapper.BASS_CONFIG_UPDATETHREADS; // The number of threads to use... 0 = disable automatic updating.
        this.BASS_CONFIG_VERIFY = this.basswrapper.BASS_CONFIG_VERIFY; // The amount of data to check, in bytes... 1000 (min) to 1000000 (max). If the value specified is outside this range, it is automatically capped.
        this.BASS_CONFIG_VERIFY_NET = this.basswrapper.BASS_CONFIG_VERIFY_NET; 
        this.BASS_CONFIG_VISTA_SPEAKERS = this.basswrapper.BASS_CONFIG_VISTA_SPEAKERS; // If TRUE, speaker assignment with panning/balance control is enabled on Windows Vista and newer.
        this.BASS_CONFIG_VISTA_TRUEPOS = this.basswrapper.BASS_CONFIG_VISTA_TRUEPOS; // If TRUE, DirectSound's "true play position" mode is enabled on Windows Vista and newer.
        this.BASS_CONFIG_3DALGORITHM = this.basswrapper.BASS_CONFIG_3DALGORITHM; // The 3D algorithm for software mixed 3D channels.
        this.BASS_CONFIG_AIRPLAY = this.basswrapper.BASS_CONFIG_AIRPLAY;
        this.BASS_CONFIG_ASYNCFILE_BUFFER = this.basswrapper.BASS_CONFIG_ASYNCFILE_BUFFER;
        this.BASS_CONFIG_BUFFER = this.basswrapper.BASS_CONFIG_BUFFER;
        this.BASS_CONFIG_CURVE_PAN = this.basswrapper.BASS_CONFIG_CURVE_PAN;
        this.BASS_CONFIG_CURVE_VOL = this.basswrapper.BASS_CONFIG_CURVE_VOL;
        this.BASS_CONFIG_DEV_BUFFER = this.basswrapper.BASS_CONFIG_DEV_BUFFER;
        this.BASS_CONFIG_DEV_NONSTOP = this.basswrapper.BASS_CONFIG_DEV_NONSTOP; // Do not stop the output device when nothing is playing on it?
        this.BASS_CONFIG_ENCODE_ACM_LOAD = this.basswrapper.BASS_CONFIG_ENCODE_ACM_LOAD;
        this.BASS_CONFIG_ENCODE_CAST_PROXY = this.basswrapper.BASS_CONFIG_ENCODE_CAST_PROXY;
        this.BASS_CONFIG_ENCODE_CAST_TIMEOUT = this.basswrapper.BASS_CONFIG_ENCODE_CAST_TIMEOUT; // The time to wait to send data to a cast server.
        this.BASS_CONFIG_ENCODE_PRIORITY = this.basswrapper.BASS_CONFIG_ENCODE_PRIORITY; // Priority of the encoder DSP.
        this.BASS_CONFIG_ENCODE_QUEUE = this.basswrapper.BASS_CONFIG_ENCODE_QUEUE; // The maximum queue length. 
        this.BASS_CONFIG_FLOATDSP = this.basswrapper.BASS_CONFIG_FLOATDSP;
        this.BASS_CONFIG_GVOL_MUSIC = this.basswrapper.BASS_CONFIG_GVOL_MUSIC;
        this.BASS_CONFIG_GVOL_SAMPLE = this.basswrapper.BASS_CONFIG_GVOL_SAMPLE;
        this.BASS_CONFIG_GVOL_STREAM = this.basswrapper.BASS_CONFIG_GVOL_STREAM;
        this.BASS_CONFIG_HANDLES = this.basswrapper.BASS_CONFIG_HANDLES;
        this.BASS_CONFIG_IOS_MIXAUDIO = this.basswrapper.BASS_CONFIG_IOS_MIXAUDIO;
        this.BASS_CONFIG_IOS_NOCATEGORY = this.basswrapper.BASS_CONFIG_IOS_NOCATEGORY;
        this.BASS_CONFIG_IOS_NOTIFY = this.basswrapper.BASS_CONFIG_IOS_NOTIFY;
        this.BASS_CONFIG_IOS_SPEAKER = this.basswrapper.BASS_CONFIG_IOS_SPEAKER;
        this.BASS_CONFIG_MF_DISABLE = this.basswrapper.BASS_CONFIG_MF_DISABLE; // Disable the use of Media Foundation?
        this.BASS_CONFIG_MF_VIDEO = this.basswrapper.BASS_CONFIG_MF_VIDEO; // Play the audio from video files using Media Foundation?
        this.BASS_CONFIG_MUSIC_VIRTUAL = this.basswrapper.BASS_CONFIG_MUSIC_VIRTUAL; // The maximum number of virtual channels to use in the rendering of IT files.
        this.BASS_CONFIG_NET_AGENT = this.basswrapper.BASS_CONFIG_NET_AGENT; // The "User-Agent" request header sent to servers.

        // CTYPE
        this.BASS_CTYPE_MUSIC_IT = this.basswrapper.BASS_CTYPE_MUSIC_IT; // Impulse Tracker format music.
        this.BASS_CTYPE_MUSIC_MO3 = this.basswrapper.BASS_CTYPE_MUSIC_MO3; // MO3 format flag, used in combination with one of the BASS_CTYPE_MUSIC types.
        this.BASS_CTYPE_MUSIC_MOD = this.basswrapper.BASS_CTYPE_MUSIC_MOD; // Generic MOD format music. This can also be used as a flag to test if the channel is any kind of HMUSIC.
        this.BASS_CTYPE_MUSIC_MTM = this.basswrapper.BASS_CTYPE_MUSIC_MTM; // MultiTracker format music.
        this.BASS_CTYPE_MUSIC_S3M = this.basswrapper.BASS_CTYPE_MUSIC_S3M; // ScreamTracker 3 format music.
        this.BASS_CTYPE_MUSIC_XM = this.basswrapper.BASS_CTYPE_MUSIC_XM; // FastTracker 2 format music.
        this.BASS_CTYPE_RECORD = this.basswrapper.BASS_CTYPE_RECORD; // Recording channel. (HRECORD)
        this.BASS_CTYPE_SAMPLE = this.basswrapper.BASS_CTYPE_SAMPLE; // Sample channel. (HCHANNEL)
        this.BASS_CTYPE_STREAM = this.basswrapper.BASS_CTYPE_STREAM; // User sample stream. This can also be used as a flag to test if the channel is any kind of HSTREAM.
        this.BASS_CTYPE_STREAM_AIFF = this.basswrapper.BASS_CTYPE_STREAM_AIFF; // Audio IFF format stream.
        this.BASS_CTYPE_STREAM_CA = this.basswrapper.BASS_CTYPE_STREAM_CA; // CoreAudio codec stream. Additional format information is avaliable from BASS_ChannelGetTags (BASS_TAG_CA_CODEC).
        this.BASS_CTYPE_STREAM_MF = this.basswrapper.BASS_CTYPE_STREAM_MF; // Media Foundation codec stream. Additional format information is avaliable from BASS_ChannelGetTags (BASS_TAG_WAVEFORMAT).
        this.BASS_CTYPE_STREAM_MIXER = this.basswrapper.BASS_CTYPE_STREAM_MIXER;
        this.BASS_CTYPE_STREAM_MP1 = this.basswrapper.BASS_CTYPE_STREAM_MP1;
        this.BASS_CTYPE_STREAM_MP2 = this.basswrapper.BASS_CTYPE_STREAM_MP2;
        this.BASS_CTYPE_STREAM_MP3 = this.basswrapper.BASS_CTYPE_STREAM_MP3;
        this.BASS_CTYPE_STREAM_OGG = this.basswrapper.BASS_CTYPE_STREAM_OGG;
        this.BASS_CTYPE_STREAM_SPLIT = this.basswrapper.BASS_CTYPE_STREAM_SPLIT;
        this.BASS_CTYPE_STREAM_WAV = this.basswrapper.BASS_CTYPE_STREAM_WAV;
        this.BASS_CTYPE_STREAM_WAV_FLOAT = this.basswrapper.BASS_CTYPE_STREAM_WAV_FLOAT; // Floating-point PCM WAVE format stream.
        this.BASS_CTYPE_STREAM_WAV_PCM = this.basswrapper.BASS_CTYPE_STREAM_WAV_PCM; // Integer PCM WAVE format stream.
        
        // Data
        this.BASS_DATA_AVAILABLE = this.basswrapper.BASS_DATA_AVAILABLE;
        this.BASS_DATA_FFT256 = this.basswrapper.BASS_DATA_FFT256;
        this.BASS_DATA_FFT512 = this.basswrapper.BASS_DATA_FFT512;
        this.BASS_DATA_FFT1024 = this.basswrapper.BASS_DATA_FFT1024;
        this.BASS_DATA_FFT2048 = this.basswrapper.BASS_DATA_FFT2048;
        this.BASS_DATA_FFT4096 = this.basswrapper.BASS_DATA_FFT4096;
        this.BASS_DATA_FFT8192 = this.basswrapper.BASS_DATA_FFT8192;
        this.BASS_DATA_FFT16384 = this.basswrapper.BASS_DATA_FFT16384;
        this.BASS_DATA_FFT_COMPLEX = this.basswrapper.BASS_DATA_FFT_COMPLEX;
        this.BASS_DATA_FFT_INDIVIDUAL = this.basswrapper.BASS_DATA_FFT_INDIVIDUAL;
        this.BASS_DATA_FFT_NOWINDOW = this.basswrapper.BASS_DATA_FFT_NOWINDOW;
        this.BASS_DATA_FFT_REMOVEDC = this.basswrapper.BASS_DATA_FFT_REMOVEDC;
        this.BASS_DATA_FIXED = this.basswrapper.BASS_DATA_FIXED;
        this.BASS_DATA_FLOAT = this.basswrapper.BASS_DATA_FLOAT;
        

        //Device

        this.BASS_DEVICE_3D = this.basswrapper.BASS_DEVICE_3D;
        this.BASS_DEVICE_8BITS = this.basswrapper.BASS_DEVICE_8BITS;
        this.BASS_DEVICE_CPSPEAKERS = this.basswrapper.BASS_DEVICE_CPSPEAKERS;
        this.BASS_DEVICE_DEFAULT = this.basswrapper.BASS_DEVICE_DEFAULT;
        this.BASS_DEVICE_DMIX = this.basswrapper.BASS_DEVICE_DMIX;
        this.BASS_DEVICE_ENABLED = this.basswrapper.BASS_DEVICE_ENABLED;
        this.BASS_DEVICE_FREQ = this.basswrapper.BASS_DEVICE_FREQ;
        this.BASS_DEVICE_INIT = this.basswrapper.BASS_DEVICE_INIT;
        this.BASS_DEVICE_LATENCY = this.basswrapper.BASS_DEVICE_LATENCY;
        this.BASS_DEVICE_MONO = this.basswrapper.BASS_DEVICE_MONO;
        this.BASS_DEVICE_NOSPEAKER = this.basswrapper.BASS_DEVICE_NOSPEAKER;
        this.BASS_DEVICE_SPEAKERS = this.basswrapper.BASS_DEVICE_SPEAKERS;
        this.BASS_DEVICE_TYPE_DIGITAL = this.basswrapper.BASS_DEVICE_TYPE_DIGITAL;
        this.BASS_DEVICE_TYPE_DISPLAYPORT = this.basswrapper.BASS_DEVICE_TYPE_DISPLAYPORT;
        this.BASS_DEVICE_TYPE_HANDSET = this.basswrapper.BASS_DEVICE_TYPE_HANDSET;
        this.BASS_DEVICE_TYPE_HDMI = this.basswrapper.BASS_DEVICE_TYPE_HDMI;
        this.BASS_DEVICE_TYPE_HEADPHONES = this.basswrapper.BASS_DEVICE_TYPE_HEADPHONES;
        this.BASS_DEVICE_TYPE_HEADSET = this.basswrapper.BASS_DEVICE_TYPE_HEADSET;
        this.BASS_DEVICE_TYPE_LINE = this.basswrapper.BASS_DEVICE_TYPE_LINE;
        this.BASS_DEVICE_TYPE_MASK = this.basswrapper.BASS_DEVICE_TYPE_MASK;
        this.BASS_DEVICE_TYPE_MICROPHONE = this.basswrapper.BASS_DEVICE_TYPE_MICROPHONE;
        this.BASS_DEVICE_TYPE_NETWORK = this.basswrapper.BASS_DEVICE_TYPE_NETWORK;
        this.BASS_DEVICE_TYPE_SPDIF = this.basswrapper.BASS_DEVICE_TYPE_SPDIF;
        this.BASS_DEVICE_TYPE_SPEAKERS = this.basswrapper.BASS_DEVICE_TYPE_SPEAKERS;
        this.BASS_DEVICE_STEREO = this.basswrapper.BASS_DEVICE_STEREO;

        // Devices
        this.BASS_DEVICES_AIRPLAY = this.basswrapper.BASS_DEVICES_AIRPLAY;
        
        // FX
        this.BASS_FX_DX8_CHORUS = this.basswrapper.BASS_FX_DX8_CHORUS;
        this.BASS_FX_DX8_COMPRESSOR = this.basswrapper.BASS_FX_DX8_COMPRESSOR;
        this.BASS_FX_DX8_DISTORTION = this.basswrapper.BASS_FX_DX8_DISTORTION;
        this.BASS_FX_DX8_ECHO = this.basswrapper.BASS_FX_DX8_ECHO;
        this.BASS_FX_DX8_FLANGER = this.basswrapper.BASS_FX_DX8_FLANGER;
        this.BASS_FX_DX8_GARGLE = this.basswrapper.BASS_FX_DX8_GARGLE;
        this.BASS_FX_DX8_I3DL2REVERB = this.basswrapper.BASS_FX_DX8_I3DL2REVERB;
        this.BASS_FX_DX8_PARAMEQ = this.basswrapper.BASS_FX_DX8_PARAMEQ;
        this.BASS_FX_DX8_REVERB = this.basswrapper.BASS_FX_DX8_REVERB;

        // DX8
        this.BASS_DX8_PHASE_90 = this.basswrapper.BASS_DX8_PHASE_90;
        this.BASS_DX8_PHASE_180 = this.basswrapper.BASS_DX8_PHASE_180;
        this.BASS_DX8_PHASE_NEG_90 = this.basswrapper.BASS_DX8_PHASE_NEG_90;
        this.BASS_DX8_PHASE_NEG_180 = this.basswrapper.BASS_DX8_PHASE_NEG_180;
        this.BASS_DX8_PHASE_ZERO = this.basswrapper.BASS_DX8_PHASE_ZERO;

        // Encode

        this.BASS_ENCODE_AIFF = this.basswrapper.BASS_ENCODE_AIFF;
        this.BASS_ENCODE_AUTOFREE = this.basswrapper.BASS_ENCODE_AUTOFREE;
        this.BASS_ENCODE_BIGEND = this.basswrapper.BASS_ENCODE_BIGEND;
        this.BASS_ENCODE_CAST_NOLIMIT = this.basswrapper.BASS_ENCODE_CAST_NOLIMIT;
        this.BASS_ENCODE_COUNT_CAST = this.basswrapper.BASS_ENCODE_COUNT_CAST;
        this.BASS_ENCODE_COUNT_IN = this.basswrapper.BASS_ENCODE_COUNT_IN;
        this.BASS_ENCODE_COUNT_OUT = this.basswrapper.BASS_ENCODE_COUNT_OUT;
        this.BASS_ENCODE_COUNT_QUEUE = this.basswrapper.BASS_ENCODE_COUNT_QUEUE;
        this.BASS_ENCODE_COUNT_QUEUE_FAIL = this.basswrapper.BASS_ENCODE_COUNT_QUEUE_FAIL;
        this.BASS_ENCODE_COUNT_QUEUE_LIMIT = this.basswrapper.BASS_ENCODE_COUNT_QUEUE_LIMIT;
        this.BASS_ENCODE_FP_8BIT = this.basswrapper.BASS_ENCODE_FP_8BIT;
        this.BASS_ENCODE_FP_16BIT = this.basswrapper.BASS_ENCODE_FP_16BIT;
        this.BASS_ENCODE_FP_24BIT = this.basswrapper.BASS_ENCODE_FP_24BIT;
        this.BASS_ENCODE_FP_32BIT = this.basswrapper.BASS_ENCODE_FP_32BIT;
        this.BASS_ENCODE_LIMIT = this.basswrapper.BASS_ENCODE_LIMIT;
        this.BASS_ENCODE_MONO = this.basswrapper.BASS_ENCODE_MONO;
        this.BASS_ENCODE_NOHEAD = this.basswrapper.BASS_ENCODE_NOHEAD;
        this.BASS_ENCODE_NOTIFY_CAST = this.basswrapper.BASS_ENCODE_NOTIFY_CAST;
        this.BASS_ENCODE_NOTIFY_CAST_TIMEOUT = this.basswrapper.BASS_ENCODE_NOTIFY_CAST_TIMEOUT;
        this.BASS_ENCODE_NOTIFY_ENCODER = this.basswrapper.BASS_ENCODE_NOTIFY_ENCODER;
        this.BASS_ENCODE_NOTIFY_FREE = this.basswrapper.BASS_ENCODE_NOTIFY_FREE;
        this.BASS_ENCODE_NOTIFY_QUEUE_FULL = this.basswrapper.BASS_ENCODE_NOTIFY_QUEUE_FULL;
        this.BASS_ENCODE_PAUSE = this.basswrapper.BASS_ENCODE_PAUSE;
        this.BASS_ENCODE_PCM = this.basswrapper.BASS_ENCODE_PCM;
        this.BASS_ENCODE_QUEUE = this.basswrapper.BASS_ENCODE_QUEUE;
        this.BASS_ENCODE_RF64 = this.basswrapper.BASS_ENCODE_RF64;
        this.BASS_ENCODE_SERVER_NOHTTP = this.basswrapper.BASS_ENCODE_SERVER_NOHTTP;
        this.BASS_ENCODE_STATS_ICE = this.basswrapper.BASS_ENCODE_STATS_ICE;
        this.BASS_ENCODE_STATS_ICESERV = this.basswrapper.BASS_ENCODE_STATS_ICESERV;
        this.BASS_ENCODE_STATS_SHOUT = this.basswrapper.BASS_ENCODE_STATS_SHOUT;
        this.BASS_ENCODE_TYPE_AAC = this.basswrapper.BASS_ENCODE_TYPE_AAC;
        this.BASS_ENCODE_TYPE_MP3 = this.basswrapper.BASS_ENCODE_TYPE_MP3;
        this.BASS_ENCODE_TYPE_OGG = this.basswrapper.BASS_ENCODE_TYPE_OGG;
        this.BASS_ENCODE_WFEXT = this.basswrapper.BASS_ENCODE_WFEXT;

        // Error
        this.BASS_ERROR_ACM_CANCEL = this.basswrapper.BASS_ERROR_ACM_CANCEL;
        this.BASS_ERROR_ALREADY = this.basswrapper.BASS_ERROR_ALREADY;
        this.BASS_ERROR_BUFLOST = this.basswrapper.BASS_ERROR_BUFLOST;
        this.BASS_ERROR_BUSY = this.basswrapper.BASS_ERROR_BUSY;
        this.BASS_ERROR_CAST_DENIED = this.basswrapper.BASS_ERROR_CAST_DENIED;
        this.BASS_ERROR_CODEC = this.basswrapper.BASS_ERROR_CODEC;
        this.BASS_ERROR_CREATE = this.basswrapper.BASS_ERROR_CREATE;
        this.BASS_ERROR_DECODE = this.basswrapper.BASS_ERROR_DECODE;
        this.BASS_ERROR_DEVICE = this.basswrapper.BASS_ERROR_DEVICE;
        this.BASS_ERROR_DRIVER = this.basswrapper.BASS_ERROR_DRIVER;
        this.BASS_ERROR_DX = this.basswrapper.BASS_ERROR_DX;
        this.BASS_ERROR_EMPTY = this.basswrapper.BASS_ERROR_EMPTY;
        this.BASS_ERROR_ENDED = this.basswrapper.BASS_ERROR_ENDED;
        this.BASS_ERROR_FILEFORM = this.basswrapper.BASS_ERROR_FILEFORM;
        this.BASS_ERROR_FILEOPEN = this.basswrapper.BASS_ERROR_FILEOPEN;
        this.BASS_ERROR_FORMAT = this.basswrapper.BASS_ERROR_FORMAT;
        this.BASS_ERROR_FREQ = this.basswrapper.BASS_ERROR_FREQ;
        this.BASS_ERROR_HANDLE = this.basswrapper.BASS_ERROR_HANDLE;
        this.BASS_ERROR_ILLPARAM = this.basswrapper.BASS_ERROR_ILLPARAM;
        this.BASS_ERROR_ILLTYPE = this.basswrapper.BASS_ERROR_ILLTYPE;
        this.BASS_ERROR_INIT = this.basswrapper.BASS_ERROR_INIT;
        this.BASS_ERROR_MEM = this.basswrapper.BASS_ERROR_MEM;
        this.BASS_ERROR_NO3D = this.basswrapper.BASS_ERROR_NO3D;
        this.BASS_ERROR_NOCHAN = this.basswrapper.BASS_ERROR_NOCHAN;
        this.BASS_ERROR_NOEAX = this.basswrapper.BASS_ERROR_NOEAX;
        this.BASS_ERROR_NOFX = this.basswrapper.BASS_ERROR_NOFX;
        this.BASS_ERROR_NOHW = this.basswrapper.BASS_ERROR_NOHW;
        this.BASS_ERROR_NONET = this.basswrapper.BASS_ERROR_NONET;
        this.BASS_ERROR_NOPLAY = this.basswrapper.BASS_ERROR_NOPLAY;
        this.BASS_ERROR_NOTAVAIL = this.basswrapper.BASS_ERROR_NOTAVAIL;
        this.BASS_ERROR_NOTFILE = this.basswrapper.BASS_ERROR_NOTFILE;
        this.BASS_ERROR_POSITION = this.basswrapper.BASS_ERROR_POSITION;
        this.BASS_ERROR_SPEAKER = this.basswrapper.BASS_ERROR_SPEAKER;
        this.BASS_ERROR_SSL = this.basswrapper.BASS_ERROR_SSL;
        this.BASS_ERROR_START = this.basswrapper.BASS_ERROR_START;
        this.BASS_ERROR_UNKNOWN = this.basswrapper.BASS_ERROR_UNKNOWN;
        this.BASS_ERROR_VERSION = this.basswrapper.BASS_ERROR_VERSION;

        // File
        this.BASS_FILEDATA_END = this.basswrapper.BASS_FILEDATA_END;
        this.BASS_FILEPOS_ASYNCBUF = this.basswrapper.BASS_FILEPOS_ASYNCBUF;
        this.BASS_FILEPOS_BUFFER = this.basswrapper.BASS_FILEPOS_BUFFER;
        this.BASS_FILEPOS_CONNECTED = this.basswrapper.BASS_FILEPOS_CONNECTED;
        this.BASS_FILEPOS_CURRENT = this.basswrapper.BASS_FILEPOS_CURRENT;
        this.BASS_FILEPOS_DECODE = this.basswrapper.BASS_FILEPOS_DECODE;
        this.BASS_FILEPOS_DOWNLOAD = this.basswrapper.BASS_FILEPOS_DOWNLOAD;
        this.BASS_FILEPOS_END = this.basswrapper.BASS_FILEPOS_END;
        this.BASS_FILEPOS_SIZE = this.basswrapper.BASS_FILEPOS_SIZE;
        this.BASS_FILEPOS_SOCKET = this.basswrapper.BASS_FILEPOS_SOCKET;
        this.BASS_FILEPOS_START = this.basswrapper.BASS_FILEPOS_START;

        // Level
        this.BASS_LEVEL_MONO = this.basswrapper.BASS_LEVEL_MONO;
        this.BASS_LEVEL_RMS = this.basswrapper.BASS_LEVEL_RMS;
        this.BASS_LEVEL_STEREO = this.basswrapper.BASS_LEVEL_STEREO;

        // Object
        this.BASS_OBJECT_DS = this.basswrapper.BASS_OBJECT_DS;
        this.BASS_OBJECT_DS3DL = this.basswrapper.BASS_OBJECT_DS3DL;

        // Ok

        this.BASS_OK = this.basswrapper.BASS_OK;

        // Pos
        this.BASS_POS_BYTE = this.basswrapper.BASS_POS_BYTE;
        this.BASS_POS_DECODE = this.basswrapper.BASS_POS_DECODE;
        this.BASS_POS_DECODETO = this.basswrapper.BASS_POS_DECODETO;
        this.BASS_POS_INEXACT = this.basswrapper.BASS_POS_INEXACT;
        this.BASS_POS_MIXER_RESET = this.basswrapper.BASS_POS_MIXER_RESET;
        this.BASS_POS_MUSIC_ORDER = this.basswrapper.BASS_POS_MUSIC_ORDER;
        this.BASS_POS_OGG = this.basswrapper.BASS_POS_OGG;
        this.BASS_POS_SCAN = this.basswrapper.BASS_POS_SCAN;

        // Input
        this.BASS_INPUT_OFF = this.basswrapper.BASS_INPUT_OFF;
        this.BASS_INPUT_ON = this.basswrapper.BASS_INPUT_ON;
        this.BASS_INPUT_TYPE_ANALOG = this.basswrapper.BASS_INPUT_TYPE_ANALOG;
        this.BASS_INPUT_TYPE_AUX = this.basswrapper.BASS_INPUT_TYPE_AUX;
        this.BASS_INPUT_TYPE_CD = this.basswrapper.BASS_INPUT_TYPE_CD;
        this.BASS_INPUT_TYPE_DIGITAL = this.basswrapper.BASS_INPUT_TYPE_DIGITAL;
        this.BASS_INPUT_TYPE_LINE = this.basswrapper.BASS_INPUT_TYPE_LINE;
        this.BASS_INPUT_TYPE_MASK = this.basswrapper.BASS_INPUT_TYPE_MASK;
        this.BASS_INPUT_TYPE_MIC = this.basswrapper.BASS_INPUT_TYPE_MIC;
        this.BASS_INPUT_TYPE_PHONE = this.basswrapper.BASS_INPUT_TYPE_PHONE;
        this.BASS_INPUT_TYPE_SPEAKER = this.basswrapper.BASS_INPUT_TYPE_SPEAKER;
        this.BASS_INPUT_TYPE_SYNTH = this.basswrapper.BASS_INPUT_TYPE_SYNTH;
        this.BASS_INPUT_TYPE_UNDEF = this.basswrapper.BASS_INPUT_TYPE_UNDEF;
        this.BASS_INPUT_TYPE_WAVE = this.basswrapper.BASS_INPUT_TYPE_WAVE;

        // Sample
        this.BASS_SAMPLE_3D = this.basswrapper.BASS_SAMPLE_3D;
        this.BASS_SAMPLE_8BITS = this.basswrapper.BASS_SAMPLE_8BITS;
        this.BASS_SAMPLE_FLOAT = this.basswrapper.BASS_SAMPLE_FLOAT;
        this.BASS_SAMPLE_FX = this.basswrapper.BASS_SAMPLE_FX;
        this.BASS_SAMPLE_LOOP = this.basswrapper.BASS_SAMPLE_LOOP;
        this.BASS_SAMPLE_MONO = this.basswrapper.BASS_SAMPLE_MONO;
        this.BASS_SAMPLE_MUTEMAX = this.basswrapper.BASS_SAMPLE_MUTEMAX;
        this.BASS_SAMPLE_OVER_DIST = this.basswrapper.BASS_SAMPLE_OVER_DIST;
        this.BASS_SAMPLE_OVER_POS = this.basswrapper.BASS_SAMPLE_OVER_POS;
        this.BASS_SAMPLE_OVER_VOL = this.basswrapper.BASS_SAMPLE_OVER_VOL;
        this.BASS_SAMPLE_SOFTWARE = this.basswrapper.BASS_SAMPLE_SOFTWARE;
        this.BASS_SAMPLE_VAM = this.basswrapper.BASS_SAMPLE_VAM;

        // Ios Notify
        this.BASS_IOSNOTIFY_INTERRUPT = this.basswrapper.BASS_IOSNOTIFY_INTERRUPT;
        this.BASS_IOSNOTIFY_INTERRUPT_END = this.basswrapper.BASS_IOSNOTIFY_INTERRUPT_END;

        // Channel Attribute
        this.BASS_ACTIVE_PAUSED = this.basswrapper.BASS_ACTIVE_PAUSED;
        this.BASS_ACTIVE_PLAYING = this.basswrapper.BASS_ACTIVE_PLAYING;
        this.BASS_ACTIVE_STALLED = this.basswrapper.BASS_ACTIVE_STALLED;
        this.BASS_ACTIVE_STOPPED = this.basswrapper.BASS_ACTIVE_STOPPED;
        this.BASS_ATTRIB_EAXMIX = this.basswrapper.BASS_ATTRIB_EAXMIX; // The wet (reverb) / dry (no reverb) mix ratio of a channel.
        this.BASS_ATTRIB_FREQ = this.basswrapper.BASS_ATTRIB_FREQ;
        this.BASS_ATTRIB_MUSIC_ACTIVE = this.basswrapper.BASS_ATTRIB_MUSIC_ACTIVE;
        this.BASS_ATTRIB_MUSIC_AMPLIFY = this.basswrapper.BASS_ATTRIB_MUSIC_AMPLIFY; // The amplification level of a MOD music. The default amplification level is 50.
        this.BASS_ATTRIB_MUSIC_BPM = this.basswrapper.BASS_ATTRIB_MUSIC_BPM;
        this.BASS_ATTRIB_MUSIC_PANSEP = this.basswrapper.BASS_ATTRIB_MUSIC_PANSEP;
        this.BASS_ATTRIB_MUSIC_PSCALER = this.basswrapper.BASS_ATTRIB_MUSIC_PSCALER;
        this.BASS_ATTRIB_MUSIC_SPEED = this.basswrapper.BASS_ATTRIB_MUSIC_SPEED;
        this.BASS_ATTRIB_MUSIC_VOL_CHAN = this.basswrapper.BASS_ATTRIB_MUSIC_VOL_CHAN;
        this.BASS_ATTRIB_MUSIC_VOL_GLOBAL = this.basswrapper.BASS_ATTRIB_MUSIC_VOL_GLOBAL;
        this.BASS_ATTRIB_MUSIC_VOL_INST = this.basswrapper.BASS_ATTRIB_MUSIC_VOL_INST; // The volume level of an instrument in a MOD music.
        this.BASS_ATTRIB_NET_RESUME = this.basswrapper.BASS_ATTRIB_NET_RESUME; // The download buffer level required to resume stalled playback. The default is 50%.
        this.BASS_ATTRIB_NOBUFFER = this.basswrapper.BASS_ATTRIB_NOBUFFER;
        this.BASS_ATTRIB_PAN = this.basswrapper.BASS_ATTRIB_PAN;
        this.BASS_ATTRIB_SCANINFO = this.basswrapper.BASS_ATTRIB_SCANINFO;
        this.BASS_ATTRIB_SPLIT_ASYNCBUFFER = this.basswrapper.BASS_ATTRIB_SPLIT_ASYNCBUFFER;
        this.BASS_ATTRIB_SPLIT_ASYNCPERIOD = this.basswrapper.BASS_ATTRIB_SPLIT_ASYNCPERIOD;
        this.BASS_ATTRIB_SRC = this.basswrapper.BASS_ATTRIB_SRC; // The sample rate conversion quality of a channel.
        this.BASS_ATTRIB_VBR = this.basswrapper.BASS_ATTRIB_VBR;
        this.BASS_ATTRIB_VOL = this.basswrapper.BASS_ATTRIB_VOL;

        // Mixer
        this.BASS_MIXER_BUFFER = this.basswrapper.BASS_MIXER_BUFFER;
        this.BASS_MIXER_DOWNMIX = this.basswrapper.BASS_MIXER_DOWNMIX;
        this.BASS_MIXER_END = this.basswrapper.BASS_MIXER_END;
        this.BASS_MIXER_ENV_FREQ = this.basswrapper.BASS_MIXER_ENV_FREQ;
        this.BASS_MIXER_ENV_LOOP = this.basswrapper.BASS_MIXER_ENV_LOOP;
        this.BASS_MIXER_ENV_PAN = this.basswrapper.BASS_MIXER_ENV_PAN;
        this.BASS_MIXER_ENV_VOL = this.basswrapper.BASS_MIXER_ENV_VOL;
        this.BASS_MIXER_LIMIT = this.basswrapper.BASS_MIXER_LIMIT;
        this.BASS_MIXER_MATRIX = this.basswrapper.BASS_MIXER_MATRIX;
        this.BASS_MIXER_NONSTOP = this.basswrapper.BASS_MIXER_NONSTOP;
        this.BASS_MIXER_NORAMPIN = this.basswrapper.BASS_MIXER_NORAMPIN;
        this.BASS_MIXER_PAUSE = this.basswrapper.BASS_MIXER_PAUSE;
        this.BASS_MIXER_POSEX = this.basswrapper.BASS_MIXER_POSEX;
        this.BASS_MIXER_RESUME = this.basswrapper.BASS_MIXER_RESUME;

        // MP3
        this.BASS_MP3_SETPOS = this.basswrapper.BASS_MP3_SETPOS;

        // Record
        this.BASS_RECORD_AGC = this.basswrapper.BASS_RECORD_AGC;
        this.BASS_RECORD_ECHOCANCEL = this.basswrapper.BASS_RECORD_ECHOCANCEL;
        this.BASS_RECORD_PAUSE = this.basswrapper.BASS_RECORD_PAUSE;

        // Music
        this.BASS_MUSIC_3D = this.basswrapper.BASS_MUSIC_3D;
        this.BASS_MUSIC_AUTOFREE = this.basswrapper.BASS_MUSIC_AUTOFREE;
        this.BASS_MUSIC_CALCLEN = this.basswrapper.BASS_MUSIC_CALCLEN;
        this.BASS_MUSIC_DECODE = this.basswrapper.BASS_MUSIC_DECODE;
        this.BASS_MUSIC_FLOAT = this.basswrapper.BASS_MUSIC_FLOAT;
        this.BASS_MUSIC_FT2MOD = this.basswrapper.BASS_MUSIC_FT2MOD;
        this.BASS_MUSIC_FX = this.basswrapper.BASS_MUSIC_FX;
        this.BASS_MUSIC_LOOP = this.basswrapper.BASS_MUSIC_LOOP;
        this.BASS_MUSIC_MONO = this.basswrapper.BASS_MUSIC_MONO;
        this.BASS_MUSIC_NONINTER = this.basswrapper.BASS_MUSIC_NONINTER;
        this.BASS_MUSIC_NOSAMPLE = this.basswrapper.BASS_MUSIC_NOSAMPLE;
        this.BASS_MUSIC_POSRESET = this.basswrapper.BASS_MUSIC_POSRESET;
        this.BASS_MUSIC_POSRESETEX = this.basswrapper.BASS_MUSIC_POSRESETEX;
        this.BASS_MUSIC_PRESCAN = this.basswrapper.BASS_MUSIC_PRESCAN;
        this.BASS_MUSIC_PT1MOD = this.basswrapper.BASS_MUSIC_PT1MOD;
        this.BASS_MUSIC_RAMP = this.basswrapper.BASS_MUSIC_RAMP;
        this.BASS_MUSIC_RAMPS = this.basswrapper.BASS_MUSIC_RAMPS;
        this.BASS_MUSIC_SINCINTER = this.basswrapper.BASS_MUSIC_SINCINTER;
        this.BASS_MUSIC_STOPBACK = this.basswrapper.BASS_MUSIC_STOPBACK;
        this.BASS_MUSIC_SURROUND = this.basswrapper.BASS_MUSIC_SURROUND;
        this.BASS_MUSIC_SURROUND2 = this.basswrapper.BASS_MUSIC_SURROUND2;

        // Mixer Attributes
        this.BASS_ATTRIB_MIXER_LATENCY = this.basswrapper.BASS_ATTRIB_MIXER_LATENCY;
        this.BASS_CONFIG_MIXER_BUFFER = this.basswrapper.BASS_CONFIG_MIXER_BUFFER;
        this.BASS_CONFIG_MIXER_POSEX = this.BASS_CONFIG_MIXER_POSEX; // How far back to keep record of source positions to make available for BASS_Mixer_ChannelGetPositionEx.

        //speaker attributes
        this.BASS_SPEAKER_FRONT = this.basswrapper.BASS_SPEAKER_FRONT;	// front speakers
        this.BASS_SPEAKER_REAR = this.basswrapper.BASS_SPEAKER_REAR;	// rear/side speakers
        this.BASS_SPEAKER_CENLFE = this.basswrapper.BASS_SPEAKER_CENLFE;	// center & LFE speakers (5.1)
        this.BASS_SPEAKER_REAR2 = this.basswrapper.BASS_SPEAKER_REAR2;	// rear center speakers (7.1)
        this.BASS_SPEAKER_LEFT = this.basswrapper.BASS_SPEAKER_LEFT;	// modifier: left
        this.BASS_SPEAKER_RIGHT = this.basswrapper.BASS_SPEAKER_RIGHT;	// modifier: right

        this.BASS_SPEAKER_FRONTLEFT = this.basswrapper.BASS_SPEAKER_FRONT | this.basswrapper.BASS_SPEAKER_LEFT;
        this.BASS_SPEAKER_FRONTRIGHT = this.basswrapper.BASS_SPEAKER_FRONT | this.basswrapper.BASS_SPEAKER_RIGHT;
        this.BASS_SPEAKER_REARLEFT = this.basswrapper.BASS_SPEAKER_REAR | this.basswrapper.BASS_SPEAKER_LEFT;
        this.BASS_SPEAKER_REARRIGHT = this.basswrapper.BASS_SPEAKER_REAR | this.basswrapper.BASS_SPEAKER_RIGHT;
        this.BASS_SPEAKER_CENTER = this.basswrapper.BASS_SPEAKER_CENLFE | this.basswrapper.BASS_SPEAKER_LEFT;
        this.BASS_SPEAKER_LFE = this.basswrapper.BASS_SPEAKER_CENLFE | this.basswrapper.BASS_SPEAKER_RIGHT;
        this.BASS_SPEAKER_REAR2LEFT = this.basswrapper.BASS_SPEAKER_REAR2 | this.basswrapper.BASS_SPEAKER_LEFT;
        this.BASS_SPEAKER_REAR2RIGHT = this.basswrapper.BASS_SPEAKER_REAR2 | this.basswrapper.BASS_SPEAKER_RIGHT;

        // Split
        this.BASS_SPLIT_POS = this.basswrapper.BASS_SPLIT_POS;
        this.BASS_SPLIT_SLAVE = this.basswrapper.BASS_SPLIT_SLAVE;
        this.BASS_STREAM_PRESCAN = this.basswrapper.BASS_STREAM_PRESCAN;
        this.BASS_STREAM_RESTRATE = this.basswrapper.BASS_STREAM_RESTRATE;
        this.BASS_STREAM_STATUS = this.basswrapper.BASS_STREAM_STATUS;

        // Stream
        this.BASS_STREAMPROC_END = this.basswrapper.BASS_STREAMPROC_END;
        this.BASS_STREAM_AUTOFREE = this.basswrapper.BASS_STREAM_AUTOFREE;
        this.BASS_STREAM_BLOCK = this.basswrapper.BASS_STREAM_BLOCK;
        this.BASS_STREAM_DECODE = this.basswrapper.BASS_STREAM_DECODE;

        // Stream File
        this.STREAMFILE_BUFFER = this.basswrapper.STREAMFILE_BUFFER;
        this.STREAMFILE_BUFFERPUSH = this.basswrapper.STREAMFILE_BUFFERPUSH;
        this.STREAMFILE_NOBUFFER = this.basswrapper.STREAMFILE_NOBUFFER;

        // Sync
        this.BASS_SYNC_DOWNLOAD = this.basswrapper.BASS_SYNC_DOWNLOAD;
        this.BASS_SYNC_END = this.basswrapper.BASS_SYNC_END;
        this.BASS_SYNC_FREE = this.basswrapper.BASS_SYNC_FREE;
        this.BASS_SYNC_META = this.basswrapper.BASS_SYNC_META;
        this.BASS_SYNC_MIXER_ENVELOPE = this.basswrapper.BASS_SYNC_MIXER_ENVELOPE;
        this.BASS_SYNC_MIXER_ENVELOPE_NODE = this.basswrapper.BASS_SYNC_MIXER_ENVELOPE_NODE;
        this.BASS_SYNC_MIXTIME = this.basswrapper.BASS_SYNC_MIXTIME;
        this.BASS_SYNC_MUSICFX = this.basswrapper.BASS_SYNC_MUSICFX;
        this.BASS_SYNC_MUSICINST = this.basswrapper.BASS_SYNC_MUSICINST;
        this.BASS_SYNC_MUSICPOS = this.basswrapper.BASS_SYNC_MUSICPOS;
        this.BASS_SYNC_OGG_CHANGE = this.basswrapper.BASS_SYNC_OGG_CHANGE;
        this.BASS_SYNC_ONETIME = this.basswrapper.BASS_SYNC_ONETIME;
        this.BASS_SYNC_POS = this.basswrapper.BASS_SYNC_POS;
        this.BASS_SYNC_SETPOS = this.basswrapper.BASS_SYNC_SETPOS;
        this.BASS_SYNC_SLIDE = this.basswrapper.BASS_SYNC_SLIDE;
        this.BASS_SYNC_STALL = this.basswrapper.BASS_SYNC_STALL;

        // Tag
        this.BASS_TAG_APE = this.basswrapper.BASS_TAG_APE;
        this.BASS_TAG_APE_BINARY = this.basswrapper.BASS_TAG_APE_BINARY;
        this.BASS_TAG_CA_CODEC = this.basswrapper.BASS_TAG_CA_CODEC;
        this.BASS_TAG_HTTP = this.basswrapper.BASS_TAG_HTTP;
        this.BASS_TAG_ICY = this.basswrapper.BASS_TAG_ICY;
        this.BASS_TAG_ID3 = this.basswrapper.BASS_TAG_ID3;
        this.BASS_TAG_ID3V2 = this.basswrapper.BASS_TAG_ID3V2;
        this.BASS_TAG_LYRICS3 = this.basswrapper.BASS_TAG_LYRICS3;
        this.BASS_TAG_META = this.basswrapper.BASS_TAG_META;
        this.BASS_TAG_MF = this.basswrapper.BASS_TAG_MF;
        this.BASS_TAG_MP4 = this.basswrapper.BASS_TAG_MP4;
        this.BASS_TAG_MUSIC_INST = this.basswrapper.BASS_TAG_MUSIC_INST;
        this.BASS_TAG_MUSIC_MESSAGE = this.basswrapper.BASS_TAG_MUSIC_MESSAGE;
        this.BASS_TAG_MUSIC_NAME = this.basswrapper.BASS_TAG_MUSIC_NAME;
        this.BASS_TAG_MUSIC_ORDERS = this.basswrapper.BASS_TAG_MUSIC_ORDERS;
        this.BASS_TAG_MUSIC_SAMPLE = this.basswrapper.BASS_TAG_MUSIC_SAMPLE;
        this.BASS_TAG_OGG = this.basswrapper.BASS_TAG_OGG;
        this.BASS_TAG_RIFF_BEXT = this.basswrapper.BASS_TAG_RIFF_BEXT;
        this.BASS_TAG_RIFF_CART = this.basswrapper.BASS_TAG_RIFF_CART;
        this.BASS_TAG_RIFF_DISP = this.basswrapper.BASS_TAG_RIFF_DISP;
        this.BASS_TAG_RIFF_INFO = this.basswrapper.BASS_TAG_RIFF_INFO;
        this.BASS_TAG_VENDOR = this.basswrapper.BASS_TAG_VENDOR;
        this.BASS_TAG_WAVEFORMAT = this.basswrapper.BASS_TAG_WAVEFORMAT;
        this.BASS_UNICODE = this.basswrapper.BASS_UNICODE;

        // Vam
        this.BASS_VAM_HARDWARE = this.basswrapper.BASS_VAM_HARDWARE;
        this.BASS_VAM_SOFTWARE = this.basswrapper.BASS_VAM_SOFTWARE;
        this.BASS_VAM_TERM_DIST = this.basswrapper.BASS_VAM_TERM_DIST;
        this.BASS_VAM_TERM_PRIO = this.basswrapper.BASS_VAM_TERM_PRIO;
        this.BASS_VAM_TERM_TIME = this.basswrapper.BASS_VAM_TERM_TIME;

        // Wave_Format
        this.WAVE_FORMAT_1M08 = this.basswrapper.WAVE_FORMAT_1M08;
        this.WAVE_FORMAT_1M16 = this.basswrapper.WAVE_FORMAT_1M16;
        this.WAVE_FORMAT_1S08 = this.basswrapper.WAVE_FORMAT_1S08;
        this.WAVE_FORMAT_1S16 = this.basswrapper.WAVE_FORMAT_1S16;
        this.WAVE_FORMAT_2M08 = this.basswrapper.WAVE_FORMAT_2M08;
        this.WAVE_FORMAT_2M16 = this.basswrapper.WAVE_FORMAT_2M16;
        this.WAVE_FORMAT_2S08 = this.basswrapper.WAVE_FORMAT_2S08;
        this.WAVE_FORMAT_2S16 = this.basswrapper.WAVE_FORMAT_2S16;
        this.WAVE_FORMAT_4M08 = this.basswrapper.WAVE_FORMAT_4M08;
        this.WAVE_FORMAT_4M16 = this.basswrapper.WAVE_FORMAT_4M16;
        this.WAVE_FORMAT_4S08 = this.basswrapper.WAVE_FORMAT_4S08;
        this.WAVE_FORMAT_4S16 = this.basswrapper.WAVE_FORMAT_4S16;

        // DSCaps
        this.DSCAPS_CERTIFIED = this.basswrapper.DSCAPS_CERTIFIED;
        this.DSCAPS_CONTINUOUSRATE = this.basswrapper.DSCAPS_CONTINUOUSRATE;
        this.DSCAPS_EMULDRIVER = this.basswrapper.DSCAPS_EMULDRIVER;
        this.DSCAPS_SECONDARY8BIT = this.basswrapper.DSCAPS_SECONDARY8BIT;
        this.DSCAPS_SECONDARY16BIT = this.basswrapper.DSCAPS_SECONDARY16BIT;
        this.DSCAPS_SECONDARYMONO = this.basswrapper.DSCAPS_SECONDARYMONO;
        this.DSCAPS_SECONDARYSTEREO = this.basswrapper.DSCAPS_SECONDARYSTEREO;
        this.DSCCAPS_CERTIFIED = this.basswrapper.DSCCAPS_CERTIFIED;
        this.DSCCAPS_EMULDRIVER = this.basswrapper.DSCCAPS_EMULDRIVER;
        
        // Eax
        this.EAX_ENVIRONMENT_ALLEY = this.basswrapper.EAX_ENVIRONMENT_ALLEY;
        this.EAX_ENVIRONMENT_ARENA = this.basswrapper.EAX_ENVIRONMENT_ARENA;
        this.EAX_ENVIRONMENT_AUDITORIUM = this.basswrapper.EAX_ENVIRONMENT_AUDITORIUM;
        this.EAX_ENVIRONMENT_BATHROOM = this.basswrapper.EAX_ENVIRONMENT_BATHROOM;
        this.EAX_ENVIRONMENT_CARPETEDHALLWAY = this.basswrapper.EAX_ENVIRONMENT_CARPETEDHALLWAY;
        this.EAX_ENVIRONMENT_CAVE = this.basswrapper.EAX_ENVIRONMENT_CAVE;
        this.EAX_ENVIRONMENT_CITY = this.basswrapper.EAX_ENVIRONMENT_CITY;
        this.EAX_ENVIRONMENT_CONCERTHALL = this.basswrapper.EAX_ENVIRONMENT_CONCERTHALL;
        this.EAX_ENVIRONMENT_COUNT = this.basswrapper.EAX_ENVIRONMENT_COUNT;
        this.EAX_ENVIRONMENT_DIZZY = this.basswrapper.EAX_ENVIRONMENT_DIZZY;
        this.EAX_ENVIRONMENT_DRUGGED = this.basswrapper.EAX_ENVIRONMENT_DRUGGED;
        this.EAX_ENVIRONMENT_GENERIC = this.basswrapper.EAX_ENVIRONMENT_GENERIC;
        this.EAX_ENVIRONMENT_HALLWAY = this.basswrapper.EAX_ENVIRONMENT_HALLWAY;
        this.EAX_ENVIRONMENT_HANGAR = this.basswrapper.EAX_ENVIRONMENT_HANGAR;
        this.EAX_ENVIRONMENT_LIVINGROOM = this.basswrapper.EAX_ENVIRONMENT_LIVINGROOM;
        this.EAX_ENVIRONMENT_PADDEDCELL = this.basswrapper.EAX_ENVIRONMENT_PADDEDCELL;
        this.EAX_ENVIRONMENT_PARKINGLOT = this.basswrapper.EAX_ENVIRONMENT_PARKINGLOT;
        this.EAX_ENVIRONMENT_PLAIN = this.basswrapper.EAX_ENVIRONMENT_PLAIN;
        this.EAX_ENVIRONMENT_PSYCHOTIC = this.basswrapper.EAX_ENVIRONMENT_PSYCHOTIC;
        this.EAX_ENVIRONMENT_QUARRY = this.basswrapper.EAX_ENVIRONMENT_QUARRY;
        this.EAX_ENVIRONMENT_ROOM = this.basswrapper.EAX_ENVIRONMENT_ROOM;
        this.EAX_ENVIRONMENT_SEWERPIPE = this.basswrapper.EAX_ENVIRONMENT_SEWERPIPE;
        this.EAX_ENVIRONMENT_STONECORRIDOR = this.basswrapper.EAX_ENVIRONMENT_STONECORRIDOR;
        this.EAX_ENVIRONMENT_STONEROOM = this.basswrapper.EAX_ENVIRONMENT_STONEROOM;
        this.EAX_ENVIRONMENT_UNDERWATER = this.basswrapper.EAX_ENVIRONMENT_UNDERWATER;

    }
/**
* @example basslib.BASS_ChannelSetAttribute(chan, basslib.BASS_ATTRIB_VOL, 0.5);
* @param chan {int} Channel name. 
* @param attrib {BASSAttribute} ex: BASS_ATTRIB_VOL
* @param value {float} 0 to 1;
*/
    BASS_ChannelSetAttribute(chan, attrib, value) {
        return this.basswrapper.BASS_ChannelSetAttribute(chan, attrib, value);
    }
/**
* @example basslib.BASS_ChannelGetAttribute(chan, basslib.BASS_ATTRIB_VOL);
* @param chan {int} Channel name. 
* @param attrib {BASSAttribute} ex: BASS_ATTRIB_VOL
*/
    BASS_ChannelGetAttribute(chan, attrib) {
        return this.basswrapper.BASS_ChannelGetAttribute(chan, attrib);
    }
/**
* @example let procToEnd = basslib.BASS_ChannelSetSync(chan, basslib.BASS_SYNC_END, 0, (handle, channel, data, user) => {
    console.log('playback finished');
});
* @param chan {int} Channel name. 
* @param attrib {BASS_ChannelSyncTypes} ex: BASS_SYNC_END, BASS_SYNC_POS
* @param pos {int} Position.
* @param callback {function}
*/
    BASS_ChannelSetSync(chan, attrib, pos, callback) {
        return this.basswrapper.BASS_ChannelSetSync(chan, attrib, pos, callback);
    }
/**
* @example let duration = basslib.BASS_ChannelBytes2Seconds(chan, basslib.BASS_ChannelGetLength(chan, 0));
* @example let position = basslib.BASS_ChannelBytes2Seconds(chan, basslib.BASS_ChannelGetPosition(chan, 0));
* @param chan {int} Channel name. 
* @param pos {int} Position.
* @param dur {int} Duration.
*/
    BASS_ChannelBytes2Seconds(chan, pos) {
        return this.basswrapper.BASS_ChannelBytes2Seconds(chan, pos);
    }
/**
* @example basslib.BASS_ChannelFlags(chan, basslib.BASS_MUSIC_SURROUND);
* @param chan {int} Channel name. 
* @param flags {BASS_ChannelFlags} see: http://www.un4seen.com/doc/#bass/BASS_ChannelFlags.html
*/
    BASS_ChannelFlags(chan, flags) {
        return this.basswrapper.BASS_ChannelFlags(chan, flags);
    }

    BASS_ChannelGetData(chan, length) {
        return this.basswrapper.BASS_ChannelGetData(chan, length);
    }

    BASS_ChannelGetDevice(chan, flags, mask) {
        return this.basswrapper.BASS_ChannelGetDevice(chan, flags, mask);
    }

    BASS_ChannelGetInfo(chan) {
        return this.basswrapper.BASS_ChannelGetInfo(chan);
    }

    BASS_ChannelGetLeftLevel(data) {
        return this.basswrapper.BASS_ChannelGetLeftLevel(data);
    }

    BASS_ChannelGetLength(chan, mode) {
        return this.basswrapper.BASS_ChannelGetLength(chan, mode);
    }

    BASS_ChannelGetLevel(chan) {
        return this.basswrapper.BASS_ChannelGetLevel(chan);
    }

    BASS_ChannelGetPosition(chan, mode) {
        return this.basswrapper.BASS_ChannelGetPosition(chan, mode);
    }

    BASS_ChannelGetRightLevel(data) {
        return this.basswrapper.BASS_ChannelGetRightLevel(data);
    }

    BASS_ChannelGetTags(chan, tags) {
        return this.basswrapper.BASS_ChannelGetTags(chan, tags);
    }
/**
* @example let isPlaying = basslib.BASS_ChannelIsActive(chan); return true or false.
* @param chan {int} Channel name. 
*/
    BASS_ChannelIsActive(chan) {
        return this.basswrapper.BASS_ChannelIsActive(chan);
    }
/**
* @example basslib.BASS_ChannelIsSliding(chan, basslib.BASS_ATTRIB_VOL); return true or false.
* @param chan {int} Channel name. 
* @param attrib {BASSAttribute} ex: BASS_ATTRIB_VOL
*/
    BASS_ChannelIsSliding(chan, attrib) {
        return this.basswrapper.BASS_ChannelIsSliding(chan, attrib);
    }

    BASS_ChannelLock(chan, lock) {
        return this.basswrapper.BASS_ChannelLock(chan, lock);
    }

    BASS_ChannelPause(chan) {
        return this.basswrapper.BASS_ChannelPause(chan);
    }
/**
* @example let play = basslib.BASS_ChannelPlay(chan, 0);
* @param chan {int} Channel name. 
* @param restart {bool} ex: true or false.
*/
    BASS_ChannelPlay(chan, restart) {
        return this.basswrapper.BASS_ChannelPlay(chan, restart);
    }

    BASS_ChannelRemoveFX(chan, fx) {
        return this.basswrapper.BASS_ChannelRemoveFX(chan, fx);
    }

    BASS_ChannelRemoveLink(chan, chanToRemove) {
        return this.basswrapper.BASS_ChannelRemoveLink(chan, chanremove);
    }
/**
* @example basslib.BASS_ChannelRemoveSync(chan, sync);
* @param chan {int} Channel name. 
* @param sync {BASS_ChannelSyncTypes} ex: BASS_SYNC_END, BASS_SYNC_POS
*/
    BASS_ChannelRemoveSync(chan, sync) {
        return this.basswrapper.BASS_ChannelRemoveSync(chan, sync);
    }
/**
* @example let pos = basslib.BASS_ChannelSeconds2Bytes(chan, position);
* @param chan {int} Channel name. 
* @param pos {int} Position.
*/
    BASS_ChannelSeconds2Bytes(chan, pos) {
        return this.basswrapper.BASS_ChannelSeconds2Bytes(chan, pos);
    }

    BASS_ChannelSetDevice(chan, device) {
        return this.basswrapper.BASS_ChannelSetDevice(chan, device);
    }

    BASS_ChannelSetFX(chan, type, priority) {
        return this.basswrapper.BASS_ChannelSetFX(chan, type, priority);
    }

    BASS_ChannelSetLink(chan, chanToAdd) {
        return this.basswrapper.BASS_ChannelSetLink(chan, chanadd);
    }
/**
* @example let setPos = basslib.BASS_ChannelSetPosition(chan, posInBytes, 0);
* @param chan {int} Channel name. 
* @param pos {int} Position.
* @param mode {int}
*/
    BASS_ChannelSetPosition(chan, pos, mode) {
        return this.basswrapper.BASS_ChannelSetPosition(chan, pos, mode);
    }
/**
* @example basslib.BASS_ChannelSlideAttribute(chan, basslib.BASS_ATTRIB_VOL, (volume / 100), fromPosition);
* @param chan {int} Channel name. 
* @param attrib {BASSATTRIB} ex. BASS_ATTRIB_VOL
* @param value {int} value to set the attrib.
* @param time {int} from the position to set the attrib.
*/
    BASS_ChannelSlideAttribute(chan, attrib, value, time) {
        return this.basswrapper.BASS_ChannelSlideAttribute(chan, attrib, value, time);
    }

    BASS_ChannelStop(chan) {
        return this.basswrapper.BASS_ChannelStop(chan);
    }

    BASS_ChannelUpdate(chan, length) {
        return this.basswrapper.BASS_ChannelUpdate(chan, length);
    }

    BASS_Encode_CastGetStats(chan, type, password) {
        return this.basswrapper.BASS_Encode_CastGetStats(chan, type, password);
    }
/**
* @example let initCast = basslib.BASS_Encode_CastInit(encoding_chan, 'http://serverToCast.com/test', 'password', basslib.BASS_ENCODE_TYPE_MP3, 'name', 'localhost:8000/test', genre, desc, headers, frequency, public?);
* @param {int} encodingchan Encoding channel
* @param {string} server server to stream.
* @param {string} password server password.
* @param {string} content Content.
* @param {string} name Name of stream.
* @param {string} url URL.
* @param {string} genre genre.
* @param {string} desc description.
* @param {string} headers  headers.
* @param {string} bitrate bitrate.
* @param {bool} isPublic if true public, if false private.
*/
    BASS_Encode_CastInit(chan, server, password, content, name, url, genre, desc, headers, bitrate, isPublic) {
        return this.basswrapper.BASS_Encode_CastInit(chan, server, password, content, name, url, genre, desc, headers, bitrate, isPublic);
    }

    BASS_Encode_CastSendMeta(chan, type, data, length) {
        return this.basswrapper.BASS_Encode_CastSendMeta(chan, type, data, length);
    }

    BASS_Encode_CastSetTitle(chan, title, url) {
        return this.basswrapper.BASS_Encode_CastSetTitle(chan, title, url);
    } 
 
    BASS_Encode_GetChannel(chan) {
        return this.basswrapper.BASS_Encode_GetChannel(chan);
    }

    BASS_Encode_GetCount(chan, count) {
        return this.basswrapper.BASS_Encode_GetCount(chan, count);
    }

    BASS_Encode_GetVersion() {
        return this.basswrapper.BASS_Encode_GetVersion();
    }

    BASS_Encode_IsActive(chan) {
        return this.basswrapper.BASS_Encode_IsActive(chan);
    }

    BASS_Encode_ServerKick(chan, client) {
        return this.basswrapper.BASS_Encode_ServerKick(chan, client);
    }

    BASS_Encode_SetChannel(chan, chanToSet) {
        return this.basswrapper.BASS_Encode_SetChannel(chan, chanToSet);
    }

    BASS_Encode_SetNotify(chan, callback) {
        return this.basswrapper.BASS_Encode_SetNotify(chan, callback);
    }

    BASS_Encode_SetPaused(chan, paused) {
        return this.basswrapper.BASS_Encode_SetPaused(chan, paused);
    }
/**
* @example let enc_chan = basslib.BASS_Encode_Start(mixer, 'lame -r -V 2 -b 56 -', basslib.BASS_ENCODE_NOHEAD);
* @param chan {int} Channel name.
* @param cmd {string} ex: 'lame -r -V 2 -b 56 -'
* @param flags  Bass encode flags ex: BASS_ENCODE_NOHEAD
*/
    BASS_Encode_Start(chan, cmd, flags) {
        return this.basswrapper.BASS_Encode_Start(chan, cmd, flags);
    }

    BASS_Encode_StartCAFile(chan, ftype, atype, flags, bitrate, filename) {
        return this.basswrapper.BASS_Encode_StartCAFile(chan, ftype, atype, flags, bitrate, filename);
    }

    BASS_Encode_StartLimit(chan, filename, flags, limit) {
        return this.basswrapper.BASS_Encode_StartLimit(chan, filename, flags, limit);
    }

    BASS_Encode_Stop(chan) {
        return this.basswrapper.BASS_Encode_Stop(chan);
    }

    BASS_Encode_StopEx(chan, queue) {
        return this.basswrapper.BASS_Encode_StopEx(chan, queue);
    }
   /**
* @example let err = basslib.BASS_ErrorGetCode();
*/
    BASS_ErrorGetCode() {
        return this.basswrapper.BASS_ErrorGetCode();
    }

    BASS_FXReset(chan) {
        return this.basswrapper.BASS_FXReset(chan);
    }

    BASS_Free() {
        return this.basswrapper.BASS_Free();
    }
    /**
* @example let cpuUsage = basslib.BASS_GetCPU();
*/
    BASS_GetCPU() {
        return this.basswrapper.BASS_GetCPU();
    }

    BASS_GetConfig(option) {
        return this.basswrapper.BASS_GetConfig(option);
    }

    BASS_GetDevice() {
        return this.basswrapper.BASS_GetDevice();
    }

    BASS_GetDeviceInfo(device) {
        return this.basswrapper.BASS_GetDeviceInfo(device);
    }

    BASS_GetInfo() {
        return this.basswrapper.BASS_GetInfo();
    }

    BASS_GetVersion() {
        return this.basswrapper.BASS_GetVersion();
    }

    BASS_GetVolume() {
        return this.basswrapper.BASS_GetVolume();
    }
/**
 * @example let initSoundCard = basslib.BASS_Init(-1, 44100, basslib.BASS_DEVICE_STEREO)
 * @param {int} device soundCard to initialize
 * @param {int} freq frequency 
 * @param {freq} flags flag to initialize with.
 */
    BASS_Init(device, freq, flags) {
        return this.basswrapper.BASS_Init(device, freq, flags);
    }

    BASS_Mixer_ChannelFlags(chan, flags, mask) {
        return this.basswrapper.BASS_Mixer_ChannelFlags(chan, flags, mask);
    }

    BASS_Mixer_ChannelGetData(chan, length) {
        return this.basswrapper.BASS_Mixer_ChannelGetData(chan, length);
    }

    BASS_Mixer_ChannelGetLevel(chan) {
        return this.basswrapper.BASS_Mixer_ChannelGetLevel(chan);
    }
/**
 * @example let getMixer = basslib.BASS_Mixer_ChannelGetMixer(chan);
 * @param {int} chan Retrives the mixer that a channel is plugged into.
 */
    BASS_Mixer_ChannelGetMixer(chan) {
        return this.basswrapper.BASS_Mixer_ChannelGetMixer(chan);
    }
/**
 * @example let getMixerPos = basslib.BASS_Mixer_ChannelGetPosition(chan, 0);
 * @param {int} chan Channel
 * @param {int} mode Mode
 */
    BASS_Mixer_ChannelGetPosition(chan, mode) {
        return this.basswrapper.BASS_Mixer_ChannelGetPosition(chan, mode);
    }

    BASS_Mixer_ChannelGetPositionEx(chan, mode, delay) {
        return this.basswrapper.BASS_Mixer_ChannelGetPositionEx(chan, mode, delay);
    }

    BASS_Mixer_ChannelRemove(chan) {
        return this.basswrapper.BASS_Mixer_ChannelRemove(chan);
    }

    BASS_Mixer_ChannelRemoveSync(chan, sync) {
        return this.basswrapper.BASS_Mixer_ChannelRemoveSync(chan, sync);
    }

    BASS_Mixer_ChannelSetEnvelopePos(chan, type, pos) {
        return this.basswrapper.BASS_Mixer_ChannelSetEnvelopePos(chan, type, pos);
    }

    BASS_Mixer_ChannelSetPosition(chan, pos, mode) {
        return this.basswrapper.BASS_Mixer_ChannelSetPosition(chan, pos, mode);
    }

    BASS_Mixer_ChannelSetSync(chan, type, param, callback) {
        return this.basswrapper.BASS_ChannelSetSync(chan, type, param, callback);
    }

    BASS_Mixer_GetVersion() {
        return this.basswrapper.BASS_Mixer_GetVersion();
    }
/**
* @example let addToMixer = basslib.BASS_Mixer_StreamAddChannel(masterMixer, channelToAdd, basslib.BASS_SAMPLE_DEFAULT);
* @param chan {int} Channel name
* @param chanToAdd {int} Name of the channel to add.
* @param flags {int} Channel Flag
*/
    BASS_Mixer_StreamAddChannel(chan, chanToAdd, flags) {
        return this.basswrapper.BASS_Mixer_StreamAddChannel(chan, chanToAdd, flags);
    }

    BASS_Mixer_StreamAddChannelEx(chan, chanToAdd, flags, start, length) {
        return this.basswrapper.BASS_Mixer_StreamAddChannelEx(chan, chanToAdd, flags, start, length);
    }
/**
* @example let masterMixer = basslib.BASS_Mixer_StreamCreate(44100, 2, basslib.BASS_SAMPLE_DEFAULT);
* @param freq {int} Frequency of channel, ex: 44100.
* @param channel count {int} Channel count
* @param flags {int} Channel Flag
*/
    BASS_Mixer_StreamCreate(freq, chan, flags) {
        return this.basswrapper.BASS_Mixer_StreamCreate(freq, chan, flags);
    }

    BASS_MusicFree(chan) {
        return this.basswrapper.BASS_MusicFree(chan);
    }

    BASS_MusicLoad(memory, file, offset, length, flags, freq) {
        return this.basswrapper.BASS_MusicLoad(memory, file, offset, length, flags, freq);
    }

    BASS_Pause() {
        return this.basswrapper.BASS_Pause();
    }

    BASS_PluginFree(chan) {
        return this.basswrapper.BASS_PluginFree(chan);
    }

    BASS_PluginLoad(file, flags) {
        return this.basswrapper.BASS_PluginLoad(file, flags);
    }

    BASS_RecordFree() {
        return this.basswrapper.BASS_RecordFree();
    }

    BASS_RecordGetDevice() {
        return this.basswrapper.BASS_RecordGetDevice();
    }

    BASS_RecordGetDeviceInfo(device) {
        return this.basswrapper.BASS_RecordGetDeviceInfo(device);
    }

    BASS_RecordGetInfo() {
        return this.basswrapper.BASS_RecordGetInfo();
    }

    BASS_RecordGetInput(input) {
        return this.basswrapper.BASS_RecordGetInput(input);
    }

    BASS_RecordGetInputName(input) {
        return this.basswrapper.BASS_RecordGetInputName(input);
    }

    BASS_RecordInit(device) {
        return this.basswrapper.BASS_RecordInit(device);
    }

    BASS_RecordSetDevice(device) {
        return this.basswrapper.BASS_RecordSetDevice(device);
    }

    BASS_RecordSetInput(input, flags, volume) {
        return this.basswrapper.BASS_RecordSetInput(input, flags, volume);
    }

    BASS_RecordStart(freq, chans, flags, callback) {
        return this.basswrapper.BASS_RecordStart(freq, chans, flags, callback);
    }

    BASS_SampleCreate(length, freq, chans, max, flags) {
        return this.basswrapper.BASS_SampleCreate(length, freq, chans, max, flags);
    }

    BASS_SampleFree(chan) {
        return this.basswrapper.BASS_SampleFree(chan);
    }

    BASS_SampleLoad(filename, max, flags) {
        return this.basswrapper.BASS_SampleLoad(filename, max, flags);
    }

    BASS_SetConfig(option, value) {
        return this.basswrapper.BASS_SetConfig(option, value);
    }

    BASS_SetDevice(device) {
        return this.basswrapper.BASS_SetDevice(device);
    }

    BASS_SetVolume(volume) {
        return this.basswrapper.BASS_SetVolume(volume);
    }
/**
* @example let available = basslib.BASS_Split_StreamGetAvailable(splitChan);
* @param chan {int} Channel name.
*/
    BASS_Split_StreamGetAvailable(chan) {
        return this.basswrapper.BASS_Split_StreamGetAvailable(channel);
    }
/**
* @example let splitSource = basslib.BASS_Split_StreamGetSource(splitChan);
* @param chan {int} Source of this chan.
*/
    BASS_Split_StreamGetSource(chan) {
        return this.basswrapper.BASS_Split_StreamGetSource(chan);
    }

    BASS_Split_StreamReset(chan) {
        return this.basswrapper.BASS_Split_StreamReset(chan);
    }

    BASS_Split_StreamResetEx(chan, offset) {
        return this.basswrapper.BASS_Split_StreamResetEx(chan, offset);
    }
/**
 * Starts (or resumes) the output.
 */
    BASS_Start() {
        return this.basswrapper.BASS_Start();
    }
/**
 * Stops the output.
 */
    BASS_Stop() {
        return this.basswrapper.BASS_Stop();
    }
/**
 
* @example let chan = basslib.BASS_StreamCreateFile(0, song, 0, 0, basslib.BASS_SAMPLE_FLOAT);
* @param memory {boolean} if its a memoryData or filename 
* @param filenameORbufferData {string | Buffer}
* @param offset {int} File position to start streaming from.
* @param length {int} Data length (needs to be set to the length of the memory stream in bytes which should be played).
* @param flags {BASSFlag} see BASSFlag. ex: basslib.BASS_SAMPLE_DEFAULT
*/
    BASS_StreamCreateFile(memory, filenameORbufferData, offset, length, flags) {
        return this.basswrapper.BASS_StreamCreateFile(memory,filenameORbufferData, offset, length, flags);
    }
/**
 
* @example let chan = basslib.BASS_StreamCreateURL('http://url.com/test.mp3', 0, basslib.BASS_SAMPLE_FLOAT);
* @param url {string} URL of the file to stream. Should begin with "http://", "https://" or "ftp://" 
* @param offset {int} File position to start streaming from.
* @param flags {BASSFlags} see BASSFlag. ex: basslib.BASS_SAMPLE_DEFAULT
*/
    BASS_StreamCreateURL(url, offset, flags) {
        return this.basswrapper.BASS_StreamCreateURL(url, offset, flags);
    }
/**
* @example let streamFree = basslib.BASS_StreamFree(chan);
* @param chan {int} Channel name. 
*/
    BASS_StreamFree(chan) {
        return this.basswrapper.BASS_StreamFree(chan);
    }

    BASS_StreamGetFilePosition(chan, mode) {
        return this.basswrapper.BASS_StreamGetFilePosition(chan, mode);
    }

    BASS_Update(length) {
        return this.basswrapper.BASS_Update(length);
    }

    /**
     * 
     * @example basslib.InitLibrary(dirname + path.sep);
     * @param {path} path of the bass library components , dont forget to put the seperator to the end of path
     */
    InitLibrary(path) {
        this.basswrapper = require(path.join(dirname, 'basswrapper.node'));
        this.basswrapper.InitLibrary(path);
    }

    BASS_Apply3D() {
        return this.basswrapper.BASS_Apply3D();
    }
}

module.exports = {
 basswrapper : basswrapper
}