/*/---------------------------------------------------------/*/
/*/ Craydent LLC node-v0.9.0                                /*/
/*/ Copyright 2011 (http://craydent.com/about)              /*/
/*/ Dual licensed under the MIT or GPL Version 2 licenses.  /*/
/*/ (http://craydent.com/license)                           /*/
/*/---------------------------------------------------------/*/
/*/---------------------------------------------------------/*/
/// <reference path="./globalTypes/global.vars.d.ts" />
/// <reference types="node" />

import * as I$COMMIT from 'craydent.http.commit'
import * as I$COOKIE from 'craydent.http.cookie'
import * as I$DEL from 'craydent.http.del'
import * as I$DELETE from 'craydent.http.delete'
import * as I$GET from 'craydent.http.get'
import * as I$HEADER from 'craydent.http.header'
import * as I$PAYLOAD from 'craydent.http.payload'
import * as I$POST from 'craydent.http.post'
import * as I$PUT from 'craydent.http.put'
import * as I$ROLLBACK from 'craydent.http.rollback'
import * as I$SET from 'craydent.http.set'
import * as IAboutEqualTo from 'craydent.aboutequalto'
import * as IAbsolutePath from 'craydent.absolutepath'
import * as IAccess from 'craydent.access'
import * as IAcronymize from 'craydent.acronymize'
import * as IAdd from 'craydent.add'
import * as IAddFlags from 'craydent.addflags'
import * as IAddObjectPrototype from 'craydent.addobjectprototype'
import * as IAggregate from 'craydent.aggregate'
import * as IAjax from 'craydent.ajax'
import * as IAppendFile from 'craydent.appendfile'
import * as IAverage from 'craydent.average'
import * as IAwaitable from 'craydent.awaitable'
import * as IBenchmarker from 'craydent.benchmarker'
import * as IBuildTree from 'craydent.buildtree'
import * as ICArray from 'craydent.carray'
import * as ICDate from 'craydent.cdate'
import * as ICFunction from 'craydent.cfunction'
import * as ICLI from 'craydent-cli'
import * as ICNumber from 'craydent.cnumber'
import * as ICObject from 'craydent.cobject'
import * as ICRegExp from 'craydent.cregexp'
import * as ICString from 'craydent.cstring'
import * as ICapitalize from 'craydent.capitalize'
import * as ICatchAll from 'craydent.catchall'
import * as IChanges from 'craydent.changes'
import * as IChmod from 'craydent.chmod'
import * as IChown from 'craydent.chown'
import * as IChromeVersion from 'craydent.chromeversion'
import * as IClearCache from 'craydent.clearcache'
import * as IClose from 'craydent.close'
import * as IClusterit from 'craydent.clusterit'
import * as ICondense from 'craydent.condense'
import * as IContains from 'craydent.contains'
import * as IConvertUTCDate from 'craydent.convertutcdate'
import * as ICopyFile from 'craydent.copyfile'
import * as ICopyObject from 'craydent.copyobject'
import * as ICount from 'craydent.count'
import * as ICout from 'craydent.cout'
import * as ICreateIndex from 'craydent.createindex'
import * as ICreateServer from 'craydent.createserver'
import * as ICuid from 'craydent.cuid'
import * as ICursor from 'craydent.cursor'
import * as ICut from 'craydent.cut'
import * as IDeleteIt from 'craydent.delete'
import * as IDistinct from 'craydent.distinct'
import * as IDuplicate from 'craydent.duplicate'
import * as IEachProperty from 'craydent.eachproperty'
import * as IEcho from 'craydent.echo'
import * as IEllipsis from 'craydent.ellipsis'
import * as IEmit from 'craydent.emit'
import * as IEnd from 'craydent.end'
import * as IEndItWith from 'craydent.enditwith'
import * as IEndsWith from 'craydent.endswith'
import * as IEndsWithAny from 'craydent.endswithany'
import * as IEquals from 'craydent.equals'
import * as IEvery from 'craydent.every'
import * as IExclude from 'craydent.exclude'
import * as IExtend from 'craydent.extend'
import * as IFchmod from 'craydent.fchmod'
import * as IFchown from 'craydent.fchown'
import * as IFdatasync from 'craydent.fdatasync'
import * as IFillTemplate from 'craydent.filltemplate'
import * as IFilter from 'craydent.filter'
import * as IFind from 'craydent.find'
import * as IFindOne from 'craydent.findone'
import * as IFirefoxVersion from 'craydent.firefoxversion'
import * as IFoo from 'craydent.foo'
import * as IFormat from 'craydent.format'
import * as IFstat from 'craydent.fstat'
import * as IFsync from 'craydent.fsync'
import * as IFtruncate from 'craydent.ftruncate'
import * as IFutimes from 'craydent.futimes'
import * as IGeneric from './models/Generics'
import * as IGetClass from 'craydent.getclass'
import * as IGetDayOfYear from 'craydent.getdayofyear'
import * as IGetGMTOffset from 'craydent.getgmtoffset'
import * as IGetKeys from 'craydent.getkeys'
import * as IGetName from 'craydent.getname'
import * as IGetParameters from 'craydent.getparameters'
import * as IGetProperty from 'craydent.getproperty'
import * as IGetSession from 'craydent.getsession'
import * as IGetSessionID from 'craydent.getsessionid'
import * as IGetSessionSync from 'craydent.getsessionsync'
import * as IGetValue from 'craydent.getvalue'
import * as IGetWeek from 'craydent.getweek'
import * as IGroup from 'craydent.group'
import * as IHas from 'craydent.has'
import * as IHighlight from 'craydent.highlight'
import * as IHttp from 'http'
import * as IIEVersion from 'craydent.ieversion'
import * as IInclude from 'craydent.include'
import * as IIndexOfAlt from 'craydent.indexofalt'
import * as IInnerJoin from 'craydent.innerjoin'
import * as IInsert from 'craydent.insert'
import * as IInsertAfter from 'craydent.insertafter'
import * as IInsertAt from 'craydent.insertat'
import * as IInsertBefore from 'craydent.insertbefore'
import * as IIreplaceAll from 'craydent.ireplaceall'
import * as IIsAmaya from 'craydent.isamaya'
import * as IIsAndroid from 'craydent.isandroid'
import * as IIsArray from 'craydent.isarray'
import * as IIsAsync from 'craydent.isasync'
import * as IIsAsyncGenerator from 'craydent.isasyncgenerator'
import * as IIsBetween from 'craydent.isbetween'
import * as IIsBlackBerry from 'craydent.isblackberry'
import * as IIsBlank from 'craydent.isblank'
import * as IIsBoolean from 'craydent.isboolean'
import * as IIsChrome from 'craydent.ischrome'
import * as IIsCuid from 'craydent.iscuid'
import * as IIsDate from 'craydent.isdate'
import * as IIsDomElement from 'craydent.isdomelement'
import * as IIsEmpty from 'craydent.isempty'
import * as IIsError from 'craydent.iserror'
import * as IIsEven from 'craydent.iseven'
import * as IIsFirefox from 'craydent.isfirefox'
import * as IIsFloat from 'craydent.isfloat'
import * as IIsFunction from 'craydent.isfunction'
import * as IIsGecko from 'craydent.isgecko'
import * as IIsGenerator from 'craydent.isgenerator'
import * as IIsGeolocation from 'craydent.isgeolocation'
import * as IIsIE from 'craydent.isie'
import * as IIsIE6 from 'craydent.isie6'
import * as IIsIPad from 'craydent.isipad'
import * as IIsIPhone from 'craydent.isiphone'
import * as IIsIPod from 'craydent.isipod'
import * as IIsInt from 'craydent.isint'
import * as IIsInvokable from 'craydent.isinvokable'
import * as IIsJSON from 'craydent.isjson'
import * as IIsKHTML from 'craydent.iskhtml'
import * as IIsLinux from 'craydent.islinux'
import * as IIsMac from 'craydent.ismac'
import * as IIsMobile from 'craydent.ismobile'
import * as IIsNull from 'craydent.isnull'
import * as IIsNullOrEmpty from 'craydent.isnullorempty'
import * as IIsNumber from 'craydent.isnumber'
import * as IIsObject from 'craydent.isobject'
import * as IIsOdd from 'craydent.isodd'
import * as IIsOpera from 'craydent.isopera'
import * as IIsPalmOS from 'craydent.ispalmos'
import * as IIsPresto from 'craydent.ispresto'
import * as IIsPrince from 'craydent.isprince'
import * as IIsPromise from 'craydent.ispromise'
import * as IIsRegExp from 'craydent.isregexp'
import * as IIsSafari from 'craydent.issafari'
import * as IIsString from 'craydent.isstring'
import * as IIsSubset from 'craydent.issubset'
import * as IIsSymbian from 'craydent.issymbian'
import * as IIsTrident from 'craydent.istrident'
import * as IIsValidDate from 'craydent.isvaliddate'
import * as IIsValidEmail from 'craydent.isvalidemail'
import * as IIsWebkit from 'craydent.iswebkit'
import * as IIsWindows from 'craydent.iswindows'
import * as IIsWindowsMobile from 'craydent.iswindowsmobile'
import * as IItemCount from 'craydent.itemcount'
import * as IJSZip from 'craydent.jszip'
import * as IJoinLeft from 'craydent.joinleft'
import * as IJoinRight from 'craydent.joinright'
import * as IKeyOf from 'craydent.keyof'
import * as ILast from 'craydent.last'
import * as ILastIndexOfAlt from 'craydent.lastindexofalt'
import * as ILchmod from 'craydent.lchmod'
import * as ILchown from 'craydent.lchown'
import * as ILimit from 'craydent.limit'
import * as ILink from 'craydent.link'
import * as ILogger from 'craydent-logger'
import * as ILogit from 'craydent.logit'
import * as ILstat from 'craydent.lstat'
import * as ILtrim from 'craydent.ltrim'
import * as IMap from 'craydent.map'
import * as IMapReduce from 'craydent.mapreduce'
import * as IMd5 from 'craydent.md5'
import * as IMerge from 'craydent.merge'
import * as IMkdir from 'craydent.mkdir'
import * as IMkdirRecursive from 'craydent.mkdirrecursive'
import * as IMkdtemp from 'craydent.mkdtemp'
import * as INamespace from 'craydent.namespace'
import * as INoop from 'craydent.noop'
import * as INormalize from 'craydent.normalize'
import * as INow from 'craydent.now'
import * as IOff from 'craydent.off'
import * as IOn from 'craydent.on'
import * as IOnce from 'craydent.once'
import * as IOpen from 'craydent.open'
import * as IOperaVersion from 'craydent.operaversion'
import * as IOrderedList from 'craydent.orderedlist'
import * as IParallelEach from 'craydent.paralleleach'
import * as IParseAdvanced from 'craydent.parseadvanced'
import * as IParseBoolean from 'craydent.parseboolean'
import * as IParseRaw from 'craydent.parseraw'
import * as IPluralize from 'craydent.pluralize'
import * as IQueue from 'craydent.queue'
import * as IRand from 'craydent.rand'
import * as IRandomIndex from 'craydent.randomindex'
import * as IRead from 'craydent.read'
import * as IReadFile from 'craydent.readfile'
import * as IReaddir from 'craydent.readdir'
import * as IReadlink from 'craydent.readlink'
import * as IRealpath from 'craydent.realpath'
import * as IRemove from 'craydent.remove'
import * as IRemoveAll from 'craydent.removeall'
import * as IRemoveAllListeners from 'craydent.removealllisteners'
import * as IRemoveAt from 'craydent.removeat'
import * as IRename from 'craydent.rename'
import * as IReplaceAll from 'craydent.replaceall'
import * as IReplaceAt from 'craydent.replaceat'
import * as IRequireDirectory from 'craydent.requiredirectory'
import * as IReverse from 'craydent.reverse'
import * as IRmdir from 'craydent.rmdir'
import * as IRtrim from 'craydent.rtrim'
import * as IRunFuncArray from 'craydent.runfuncarray'
import * as ISafariVersion from 'craydent.safariversion'
import * as ISanitize from 'craydent.sanitize'
import * as IScramble from 'craydent.scramble'
import * as ISend from 'craydent.send'
import * as IServerManager from 'craydent.servermanager'
import * as ISet from 'craydent.set'
import * as ISetHeader from 'craydent.set-header'
import * as ISetProperty from 'craydent.setproperty'
import * as ISingularize from 'craydent.singularize'
import * as ISortBy from 'craydent.sortby'
import * as IStartItWith from 'craydent.startitwith'
import * as IStartsWith from 'craydent.startswith'
import * as IStartsWithAny from 'craydent.startswithany'
import * as IStat from 'craydent.stat'
import * as IStdev from 'craydent.stdev'
import * as IStringifyAdvanced from 'craydent.stringifyadvanced'
import * as IStrip from 'craydent.strip'
import * as ISubstringBetween from 'craydent.substringbetween'
import * as ISubstringEndAt from 'craydent.substringendat'
import * as ISubstringStartFrom from 'craydent.substringstartfrom'
import * as ISuid from 'craydent.suid'
import * as ISum from 'craydent.sum'
import * as ISymlink from 'craydent.symlink'
import * as ISyncroit from 'craydent.syncroit'
import * as IToCurrencyNotation from 'craydent.tocurrencynotation'
import * as IToDateTime from 'craydent.todatetime'
import * as IToMap from 'craydent.tomap'
import * as IToObject from 'craydent.toobject'
import * as IToPromise from 'craydent.topromise'
import * as IToSet from 'craydent.toset'
import * as IToStringAlt from 'craydent.tostringalt'
import * as ITruncate from 'craydent.truncate'
import * as ITryEval from 'craydent.tryeval'
import * as IUniversalTrim from 'craydent.universaltrim'
import * as IUnlink from 'craydent.unlink'
import * as IUpdate from 'craydent.update'
import * as IUpsert from 'craydent.upsert'
import * as IUtimes from 'craydent.utimes'
import * as IVarDump from 'craydent.vardump'
import * as IWait from 'craydent.wait'
import * as IWhere from 'craydent.where'
import * as IWrite from 'craydent.write'
import * as IWriteFile from 'craydent.writefile'
import * as IWriteSession from 'craydent.writesession'
import * as IXmlToJson from './models/XmlToJson'
import * as IYieldable from 'craydent.yieldable'
import * as IZipit from 'craydent.zipit'
import * as IPrototypes from './__prototypes';

declare global {
    interface Craydent {
        CArray: typeof ICArray.default;
        add: typeof IAdd.default;
        aggregate: typeof IAggregate.default;
        average: typeof IAverage.default;
        condense: typeof ICondense.default;
        contains: typeof IContains.default;
        count: typeof ICount.default;
        createIndex: typeof ICreateIndex.default;
        buildTree: typeof IBuildTree.default;
        delete: typeof IDeleteIt.default;
        distinct: typeof IDistinct.default;
        equals: typeof IEquals.default;
        filter: typeof IFilter.default;
        find: typeof IFind.default;
        findOne: typeof IFindOne.default;
        every: typeof IEvery.default;
        getValue: typeof IGetValue.default;
        group: typeof IGroup.default;
        indexOfAlt: typeof IIndexOfAlt.default;
        innerJoin: typeof IInnerJoin.default;
        insert: typeof IInsert.default;
        insertAfter: typeof IInsertAfter.default;
        insertAt: typeof IInsertAt.default;
        insertBefore: typeof IInsertBefore.default;
        isEmpty: typeof IIsEmpty.default;
        isSubset: typeof IIsSubset.default;
        joinLeft: typeof IJoinLeft.default;
        joinRight: typeof IJoinRight.default;
        last: typeof ILast.default;
        limit: typeof ILimit.default;
        map: typeof IMap.default;
        mapReduce: typeof IMapReduce.default;
        normalize: typeof INormalize.default;
        parallelEach: typeof IParallelEach.default;
        randomIndex: typeof IRandomIndex.default;
        remove: typeof IRemove.default;
        removeAll: typeof IRemoveAll.default;
        removeAt: typeof IRemoveAt.default;
        replaceAt: typeof IReplaceAt.default;
        scramble: typeof IScramble.default;
        sortBy: typeof ISortBy.default;
        stdev: typeof IStdev.default;
        sum: typeof ISum.default;
        toMap: typeof IToMap.default;
        toSet: typeof IToSet.default;
        trim: typeof IUniversalTrim.default;
        update: typeof IUpdate.default;
        upsert: typeof IUpsert.default;
        where: typeof IWhere.default;
    }
    //#region proto
    interface Array<T> {
        add: typeof IPrototypes._add;
        aggregate: typeof IPrototypes._aggregate;
        average: typeof IPrototypes._average;
        condense: typeof IPrototypes._condense;
        contains: typeof IPrototypes._contains;
        count: typeof IPrototypes._count;
        createIndex: typeof IPrototypes._createIndex;
        buildTree: typeof IPrototypes._buildTree;
        delete: typeof IPrototypes._delete;
        distinct: typeof IPrototypes._distinct;
        equals: typeof IPrototypes._equals;
        findOne: typeof IPrototypes._findOne;
        getValue: typeof IPrototypes._getValue;
        group: typeof IPrototypes._group;
        indexOfAlt: typeof IPrototypes._indexOfAlt;
        innerJoin: typeof IPrototypes._innerJoin;
        insert: typeof IPrototypes._insert;
        insertAfter: typeof IPrototypes._insertAfter;
        insertAt: typeof IPrototypes._insertAt;
        insertBefore: typeof IPrototypes._insertBefore;
        isEmpty: typeof IPrototypes._isEmpty;
        isSubset: typeof IPrototypes._isSubset;
        joinLeft: typeof IPrototypes._joinLeft;
        joinRight: typeof IPrototypes._joinRight;
        last: typeof IPrototypes._last;
        limit: typeof IPrototypes._limit;
        mapReduce: typeof IPrototypes._mapReduce;
        normalize: typeof IPrototypes._normalize;
        parallelEach: typeof IPrototypes._parallelEach;
        randomIndex: typeof IPrototypes._randomIndex;
        remove: typeof IPrototypes._remove;
        removeAll: typeof IPrototypes._removeAll;
        removeAt: typeof IPrototypes._removeAt;
        replaceAt: typeof IPrototypes._replaceAt;
        scramble: typeof IPrototypes._scramble;
        sortBy: typeof IPrototypes._sortBy;
        stdev: typeof IPrototypes._stdev;
        sum: typeof IPrototypes._sum;
        toMap: typeof IPrototypes._toMap;
        toSet: typeof IPrototypes._toSet;
        trim: typeof IPrototypes._trim;
        update: typeof IPrototypes._update;
        upsert: typeof IPrototypes._upsert;
        where: typeof IPrototypes._where;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
}


declare global {
    interface Craydent {
        Benchmarker: typeof IBenchmarker.default;
        Cursor: typeof ICursor.default;
        OrderedList: typeof IOrderedList.default;
        Queue: typeof IQueue.default;
        Set: typeof ISet.default;

    }

    //#region proto
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        CLI: typeof ICLI.default;
    }
    //#region proto
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        parallelEach: typeof IParallelEach.default;
        awaitable: typeof IAwaitable.default;
        syncroit: typeof ISyncroit.default;
        yieldable: typeof IYieldable.default;
    }
    //#region proto
    interface Array<T> {
        parallelEach: typeof IPrototypes._parallelEach;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        CDate: typeof ICDate.default;
        equals: typeof IEquals.default;
        format: typeof IFormat.default;
        getDayOfYear: typeof IGetDayOfYear.default;
        getGMTOffset: typeof IGetGMTOffset.default;
        getValue: typeof IGetValue.default;
        getWeek: typeof IGetWeek.default;
        isValidDate: typeof IIsValidDate.default;
        now: typeof INow.default;
    }
    //#region proto
    interface Date {
        equals: typeof IPrototypes._equals;
        format: typeof IPrototypes._format;
        getDayOfYear: typeof IPrototypes._getDayOfYear;
        getGMTOffset: typeof IPrototypes._getGMTOffset;
        getValue: typeof IPrototypes._getValue;
        getWeek: typeof IPrototypes._getWeek;
        isValidDate: typeof IPrototypes._isValidDate;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        on: typeof IOn.default;
        once: typeof IOnce.default;
        off: typeof IOff.default;
        emit: typeof IEmit.default;
        removeAllListeners: typeof IRemoveAllListeners.default;
    }
    //#region proto
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        access: typeof IAccess.default;
        appendFile: typeof IAppendFile.default;
        chmod: typeof IChmod.default;
        chown: typeof IChown.default;
        close: typeof IClose.default;
        copyFile: typeof ICopyFile.default;
        fchmod: typeof IFchmod.default;
        fchown: typeof IFchown.default;
        fdatasync: typeof IFdatasync.default;
        fstat: typeof IFstat.default;
        fsync: typeof IFsync.default;
        ftruncate: typeof IFtruncate.default;
        futimes: typeof IFutimes.default;
        lchmod: typeof ILchmod.default;
        lchown: typeof ILchown.default;
        link: typeof ILink.default;
        lstat: typeof ILstat.default;
        mkdir: typeof IMkdir.default;
        mkdtemp: typeof IMkdtemp.default;
        open: typeof IOpen.default;
        read: typeof IRead.default;
        readdir: typeof IReaddir.default;
        readFile: typeof IReadFile.default;
        readlink: typeof IReadlink.default;
        realpath: typeof IRealpath.default;
        rename: typeof IRename.default;
        rmdir: typeof IRmdir.default;
        stat: typeof IStat.default;
        symlink: typeof ISymlink.default;
        truncate: typeof ITruncate.default;
        unlink: typeof IUnlink.default;
        utimes: typeof IUtimes.default;
        write: typeof IWrite.default;
        writeFile: typeof IWriteFile.default;
    }
    //#region proto
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        CFunction: typeof ICFunction.default;
        equals: typeof IEquals.default;
        // next: typeof INext.default;
        // emit: typeof IEmit.default;
        namespace: typeof INamespace.default;
        extend: typeof IExtend.default;
        toPromise: typeof IToPromise.default;
        getParameters: typeof IGetParameters.default;
        getName: typeof IGetName.default;
        getValue: typeof IGetValue.default;
        // on: typeof IOn.default;
        // then: typeof IThen.default;
        // catch: typeof ICatch.default;
    }
    //#region proto
    interface Function {
        equals: typeof IPrototypes._equals;
        extend: typeof IPrototypes._extend;
        toPromise: typeof IPrototypes._toPromise;
        getParameters: typeof IPrototypes._getParameters;
        getName: typeof IPrototypes._getName;
        getValue: typeof IPrototypes._getValue;
        // on: typeof IPrototypes._on;
        // then: typeof IPrototypes._then;
        // catch: typeof IPrototypes._catch;
    }
    interface Generator {
        toPromise: typeof IPrototypes._toPromise;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        onhashchange: Function;
        BALANCE_SERVER_LIST: string[];
        RESPONSES: typeof IPrototypes.RESPONSES;
        HTTP_STATUS_TEMPLATE: typeof IPrototypes.HTTP_STATUS_TEMPLATE;
        PROTOCOL: string;
        SERVER: string;
        SERVER_PATH: string;
        REFERER: string;
        ORIGIN: string;
        PRAGMA: string;
        ACCEPT_ENCODING: string;
        ACCEPT_LANGUAGE: string;
        REFERER_IP: string;
        BROWSER: {
            CURRENT: string;
            CURRENT_VERSION: number;
            IE: boolean;
            IE_VERSION: number;
            IE6: boolean;
            IE7: boolean;
            IE8: boolean;
            CHROME: boolean;
            CHROME_VERSION: number;
            FIREFOX: boolean;
            FIREFOX_VERSION: number;
            OPERA: boolean;
            OPERA_VERSION: number;
            SAFARI: boolean;
            SAFARI_VERSION: number;
        };
        CLIENT: {
            BROWSER: string;
            CORES_SUPPORT: boolean;
            DEVICE: string;
            ENGINE: string;
            OS: string;
        };
        ENGINE: {
            CURRENT: string;
            AMAYA: boolean;
            GEKKO: boolean;
            KHTML: boolean;
            PRESTO: boolean;
            PRINCE: boolean;
            TRIDENT: boolean;
            WEBKIT: boolean;
        };
        OS: {
            CURRENT: string;
            ANDROID: boolean;
            BLACKBERRY: boolean;
            LINUX: boolean;
            IOS: boolean;
            MAC: boolean;
            PALM: boolean;
            SYMBIAN: boolean;
            WINDOWS: boolean;
            WINDOWS_MOBILE: boolean;
        };
        DEVICE: {
            CURRENT: string,
            ANDROID: boolean;
            BLACKBERRY: boolean;
            IPAD: boolean;
            IPHONE: boolean;
            IPOD: boolean;
            LINUX: boolean;
            MAC: boolean;
            PALM: boolean;
            SYMBIAN: boolean;
            WINDOWS: boolean;
            WINDOWS_MOBILE: boolean;
        };
        ANDROID: boolean;
        AMAYA: boolean;
        BLACKBERRY: boolean;
        CHROME: boolean;
        CHROME_VERSION: number;
        CORES_SUPPORT: boolean;
        DEBUG_MODE: boolean;
        FIREFOX: boolean;
        FIREFOX_VERSION: number;
        GEKKO: boolean;
        IE: boolean;
        IE_VERSION: number;
        IE6: boolean;
        IE7: boolean;
        IE8: boolean;
        IPAD: boolean;
        IPHONE: boolean;
        IPOD: boolean;
        KHTML: boolean;
        LINUX: boolean;
        MAC: boolean;
        OPERA: boolean;
        OPERA_VERSION: number;
        PAGE_NAME: string;
        PAGE_NAME_RAW: string;
        PALM: boolean;
        PRESTO: boolean;
        PRINCE: boolean;
        SAFARI: boolean;
        SAFARI_VERSION: number;
        SYMBIAN: boolean;
        TRIDENT: boolean;
        VERBOSE_LOGS: boolean;
        VERSION: string;
        WEBKIT: boolean;
        WINDOWS: boolean;
        WINDOWS_MOBILE: boolean;

        sessionid: string;
        session: IGeneric.AnyObject;
        request: IHttp.IncomingMessage;
        response: IHttp.ServerResponse;
        $l: Location;
        location: Location;
        navigator: Navigator;

        $COOKIE: typeof I$COOKIE.default;
        $DELETE: typeof I$DELETE.default;
        $DEL: typeof I$DEL.default;
        $GET: typeof I$GET.default;
        $HEADER: typeof I$HEADER.default;
        $PAYLOAD: typeof I$PAYLOAD.default;
        $POST: typeof I$POST.default;
        $PUT: typeof I$PUT.default;
        ChromeVersion: typeof IChromeVersion.default;
        FirefoxVersion: typeof IFirefoxVersion.default;
        IEVersion: typeof IIEVersion.default;
        OperaVersion: typeof IOperaVersion.default;
        SafariVersion: typeof ISafariVersion.default;
        isAmaya: typeof IIsAmaya.default;
        isAndroid: typeof IIsAndroid.default;
        isBlackBerry: typeof IIsBlackBerry.default;
        isChrome: typeof IIsChrome.default;
        isFirefox: typeof IIsFirefox.default;
        isGecko: typeof IIsGecko.default;
        isIE6: typeof IIsIE6.default;
        isIE: typeof IIsIE.default;
        isIPad: typeof IIsIPad.default;
        isIPhone: typeof IIsIPhone.default;
        isIPod: typeof IIsIPod.default;
        isKHTML: typeof IIsKHTML.default;
        isLinux: typeof IIsLinux.default;
        isMac: typeof IIsMac.default;
        isMobile: typeof IIsMobile.default;
        isOpera: typeof IIsOpera.default;
        isPalmOS: typeof IIsPalmOS.default;
        isPresto: typeof IIsPresto.default;
        isPrince: typeof IIsPrince.default;
        isSafari: typeof IIsSafari.default;
        isSymbian: typeof IIsSymbian.default;
        isTrident: typeof IIsTrident.default;
        isWebkit: typeof IIsWebkit.default;
        isWindows: typeof IIsWindows.default;
        isWindowsMobile: typeof IIsWindowsMobile.default;
        createServer: typeof ICreateServer.default;
        echo: typeof IEcho.default;
        end: typeof IEnd.default;
        getSessionID: typeof IGetSessionID.default;
        getSession: typeof IGetSession.default;
        getSessionSync: typeof IGetSessionSync.default;
        header: typeof ISetHeader.default;
        raw: string;
        rawData: any;
        send: typeof ISend.default;
        varDump: typeof IVarDump.default;
        writeSession: typeof IWriteSession.default;

        ServerManager: typeof IServerManager.default;
        GarbageCollector: any[];
    }
    //#region proto
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        isArray: typeof IIsArray.default;
        isAsync: typeof IIsAsync.default;
        isAsyncGenerator: typeof IIsAsyncGenerator.default;
        isBetween: typeof IIsBetween.default;
        isBlank: typeof IIsBlank.default;
        isBoolean: typeof IIsBoolean.default;
        isCuid: typeof IIsCuid.default;
        isDate: typeof IIsDate.default;
        isDomElement: typeof IIsDomElement.default;
        isEmpty: typeof IIsEmpty.default;
        isError: typeof IIsError.default;
        isEven: typeof IIsEven.default;
        isFloat: typeof IIsFloat.default;
        isFunction: typeof IIsFunction.default;
        isGenerator: typeof IIsGenerator.default;
        isGeolocation: typeof IIsGeolocation.default;
        isInt: typeof IIsInt.default;
        isInvokable: typeof IIsInvokable.default;
        isJSON: typeof IIsJSON.default;
        isNull: typeof IIsNull.default;
        isNullOrEmpty: typeof IIsNullOrEmpty.default;
        isNumber: typeof IIsNumber.default;
        isObject: typeof IIsObject.default;
        isOdd: typeof IIsOdd.default;
        isPromise: typeof IIsPromise.default;
        isRegExp: typeof IIsRegExp.default;
        isString: typeof IIsString.default;
        isSubset: typeof IIsSubset.default;
        isValidDate: typeof IIsValidDate.default;
        isValidEmail: typeof IIsValidEmail.default;
    }
    //#region proto
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        parseAdvanced: typeof IParseAdvanced.default;
        stringifyAdvanced: typeof IStringifyAdvanced.default;
    }
    //#region proto
    interface JSON {
        parseAdvanced: typeof IParseAdvanced.default;
        stringifyAdvanced: typeof IStringifyAdvanced.default;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        logger: typeof ILogger.default;
    }
    //#region proto
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        CNumber: typeof ICNumber.default;
        aboutEqualTo: typeof IAboutEqualTo.default;
        contains: typeof IContains.default;
        equals: typeof IEquals.default;
        getValue: typeof IGetValue.default;
        isBetween: typeof IIsBetween.default;
        isEven: typeof IIsEven.default;
        isOdd: typeof IIsOdd.default;
        toCurrencyNotation: typeof IToCurrencyNotation.default;
        rand: typeof IRand.default;
    }
    //#region proto
    interface Number {
        aboutEqualTo: typeof IPrototypes._aboutEqualTo;
        contains: typeof IPrototypes._contains;
        equals: typeof IPrototypes._equals;
        getValue: typeof IPrototypes._getValue;
        isBetween: typeof IPrototypes._isBetween;
        isEven: typeof IPrototypes._isEven;
        isOdd: typeof IPrototypes._isOdd;
        toCurrencyNotation: typeof IPrototypes._toCurrencyNotation;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        CObject: typeof ICObject.default;
        addObjectPrototype: typeof IAddObjectPrototype.default;
        changes: typeof IChanges.default;
        contains: typeof IContains.default;
        copyObject: typeof ICopyObject.default;
        count: typeof ICount.default;
        duplicate: typeof IDuplicate.default;
        eachProperty: typeof IEachProperty.default;
        equals: typeof IEquals.default;
        every: typeof IEvery.default;
        get: typeof IGetProperty.default;
        getClass: typeof IGetClass.default;
        getKeys: typeof IGetKeys.default;
        getProperty: typeof IGetProperty.default;
        getValue: typeof IGetValue.default;
        has: typeof IHas.default;
        isArray: typeof IIsArray.default;
        isAsync: typeof IIsAsync.default;
        isBetween: typeof IIsBetween.default;
        isBoolean: typeof IIsBoolean.default;
        isDate: typeof IIsDate.default;
        isDomElement: typeof IIsDomElement.default;
        isEmpty: typeof IIsEmpty.default;
        isError: typeof IIsError.default;
        isFloat: typeof IIsFloat.default;
        isFunction: typeof IIsFunction.default;
        isGenerator: typeof IIsGenerator.default;
        isGeolocation: typeof IIsGeolocation.default;
        isInt: typeof IIsInt.default;
        isNumber: typeof IIsNumber.default;
        isPromise: typeof IIsPromise.default;
        isObject: typeof IIsObject.default;
        isRegExp: typeof IIsRegExp.default;
        isString: typeof IIsString.default;
        isSubset: typeof IIsSubset.default;
        itemCount: typeof IItemCount.default;
        keyOf: typeof IKeyOf.default;
        map: typeof IMap.default;
        merge: typeof IMerge.default;
        set: typeof ISetProperty.default;
        setProperty: typeof ISetProperty.default;
        toStringAlt: typeof IToStringAlt.default;
    }
    //#region proto
    interface Object {
        changes: typeof IPrototypes._changes;
        contains: typeof IPrototypes._contains;
        copyObject: typeof IPrototypes._copyObject;
        count: typeof IPrototypes._count;
        duplicate: typeof IPrototypes._duplicate;
        eachProperty: typeof IPrototypes._eachProperty;
        equals: typeof IPrototypes._equals;
        every: typeof IPrototypes._every;
        get: typeof IPrototypes._get;
        getClass: typeof IPrototypes._getClass;
        getKeys: typeof IPrototypes._getKeys;
        getProperty: typeof IPrototypes._getProperty;
        getValue: typeof IPrototypes._getValue;
        has: typeof IPrototypes._has;
        isArray: typeof IPrototypes._isArray;
        isAsync: typeof IPrototypes._isAsync;
        isBetween: typeof IPrototypes._isBetween;
        isBoolean: typeof IPrototypes._isBoolean;
        isDate: typeof IPrototypes._isDate;
        isDomElement: typeof IPrototypes._isDomElement;
        isEmpty: typeof IPrototypes._isEmpty;
        isError: typeof IPrototypes._isError;
        isFloat: typeof IPrototypes._isFloat;
        isFunction: typeof IPrototypes._isFunction;
        isGenerator: typeof IPrototypes._isGenerator;
        isGeolocation: typeof IPrototypes._isGeolocation;
        isInt: typeof IPrototypes._isInt;
        isNumber: typeof IPrototypes._isNumber;
        isPromise: typeof IPrototypes._isPromise;
        isObject: typeof IPrototypes._isObject;
        isRegExp: typeof IPrototypes._isRegExp;
        isString: typeof IPrototypes._isString;
        isSubset: typeof IPrototypes._isSubset;
        itemCount: typeof IPrototypes._itemCount;
        keyOf: typeof IPrototypes._keyOf;
        map: typeof IPrototypes._map;
        merge: typeof IPrototypes._merge;
        set: typeof IPrototypes._set;
        setProperty: typeof IPrototypes._setProperty;
        toStringAlt: typeof IPrototypes._toStringAlt;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        CRegExp: typeof ICRegExp.default;
        addFlags: typeof IAddFlags.default;
        equals: typeof IEquals.default;
        getValue: typeof IGetValue.default;
    }
    //#region proto
    interface RegExp {
        addFlags: typeof IPrototypes._addFlags;
        equals: typeof IPrototypes._equals;
        getValue: typeof IPrototypes._getValue;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        CString: typeof ICString.default;
        acronymize: typeof IAcronymize.default;
        contains: typeof IContains.default;
        capitalize: typeof ICapitalize.default;
        convertUTCDate: typeof IConvertUTCDate.default;
        count: typeof ICount.default;
        cut: typeof ICut.default;
        ellipsis: typeof IEllipsis.default;
        endItWith: typeof IEndItWith.default;
        endsWith: typeof IEndsWith.default;
        endsWithAny: typeof IEndsWithAny.default;
        equals: typeof IEquals.default;
        getValue: typeof IGetValue.default;
        highlight: typeof IHighlight.default;
        indexOfAlt: typeof IIndexOfAlt.default;
        ireplace_all: typeof IIreplaceAll.default;
        ireplaceAll: typeof IIreplaceAll.default;
        isBlank: typeof IIsBlank.default;
        isCuid: typeof IIsCuid.default;
        isValidEmail: typeof IIsValidEmail.default;
        lastIndexOfAlt: typeof ILastIndexOfAlt.default;
        ltrim: typeof ILtrim.default;
        pluralize: typeof IPluralize.default;
        randomIndex: typeof IRandomIndex.default;
        replace_all: typeof IReplaceAll.default;
        replaceAll: typeof IReplaceAll.default;
        reverse: typeof IReverse.default;
        rtrim: typeof IRtrim.default;
        sanitize: typeof ISanitize.default;
        singularize: typeof ISingularize.default;
        startItWith: typeof IStartItWith.default;
        startsWith: typeof IStartsWith.default;
        startsWithAny: typeof IStartsWithAny.default;
        strip: typeof IStrip.default;
        substringBetween: typeof ISubstringBetween.default;
        substringStartFrom: typeof ISubstringStartFrom.default;
        substringEndAt: typeof ISubstringEndAt.default;
        toCurrencyNotation: typeof IToCurrencyNotation.default;
        toDateTime: typeof IToDateTime.default;
        toObject: typeof IToObject.default;
        universalTrim: typeof IUniversalTrim.default;
    }
    //#region proto
    interface String {
        acronymize: typeof IPrototypes._acronymize;
        contains: typeof IPrototypes._contains;
        capitalize: typeof IPrototypes._capitalize;
        convertUTCDate: typeof IPrototypes._convertUTCDate;
        count: typeof IPrototypes._count;
        cut: typeof IPrototypes._cut;
        ellipsis: typeof IPrototypes._ellipsis;
        endItWith: typeof IPrototypes._endItWith;
        endsWithAny: typeof IPrototypes._endsWithAny;
        equals: typeof IPrototypes._equals;
        getValue: typeof IPrototypes._getValue;
        highlight: typeof IPrototypes._highlight;
        indexOfAlt: typeof IPrototypes._indexOfAlt;
        ireplace_all: typeof IPrototypes._ireplaceAll;
        ireplaceAll: typeof IPrototypes._ireplaceAll;
        isBlank: typeof IPrototypes._isBlank;
        isCuid: typeof IPrototypes._isCuid;
        isValidEmail: typeof IPrototypes._isValidEmail;
        lastIndexOfAlt: typeof IPrototypes._lastIndexOfAlt;
        ltrim: typeof IPrototypes._ltrim;
        pluralize: typeof IPrototypes._pluralize;
        randomIndex: typeof IPrototypes._randomIndex;
        replace_all: typeof IPrototypes._replaceAll;
        replaceAll: typeof IPrototypes._replaceAll;
        reverse: typeof IPrototypes._reverse;
        rtrim: typeof IPrototypes._rtrim;
        sanitize: typeof IPrototypes._sanitize;
        singularize: typeof IPrototypes._singularize;
        startItWith: typeof IPrototypes._startItWith;
        startsWithAny: typeof IPrototypes._startsWithAny;
        strip: typeof IPrototypes._strip;
        substringBetween: typeof IPrototypes._substringBetween;
        substringStartFrom: typeof IPrototypes._substringStartFrom;
        substringEndAt: typeof IPrototypes._substringEndAt;
        toCurrencyNotation: typeof IPrototypes._toCurrencyNotation;
        toDateTime: typeof IPrototypes._toDateTime;
        toObject: typeof IPrototypes._toObject;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        fillTemplate: typeof IFillTemplate.default;
    }
    //#region proto
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        isArray: typeof IIsArray.default;
        isAsync: typeof IIsAsync.default;
        isBetween: typeof IIsBetween.default;
        isBoolean: typeof IIsBoolean.default;
        isDate: typeof IIsDate.default;
        isDomElement: typeof IIsDomElement.default;
        isEmpty: typeof IIsEmpty.default;
        isError: typeof IIsError.default;
        isFloat: typeof IIsFloat.default;
        isFunction: typeof IIsFunction.default;
        isGenerator: typeof IIsGenerator.default;
        isGeolocation: typeof IIsGeolocation.default;
        isInt: typeof IIsInt.default;
        isNull: typeof IIsNull.default;
        isNullOrEmpty: typeof IIsNullOrEmpty.default;
        isNumber: typeof IIsNumber.default;
        isObject: typeof IIsObject.default;
        isPromise: typeof IIsPromise.default;
        isRegExp: typeof IIsRegExp.default;
        isString: typeof IIsString.default;
    }
    //#region proto
    interface Object {
        isArray: typeof IPrototypes._isArray;
        isAsync: typeof IPrototypes._isAsync;
        isBetween: typeof IPrototypes._isBetween;
        isBoolean: typeof IPrototypes._isBoolean;
        isDate: typeof IPrototypes._isDate;
        isDomElement: typeof IPrototypes._isDomElement;
        isEmpty: typeof IPrototypes._isEmpty;
        isError: typeof IPrototypes._isError;
        isFloat: typeof IPrototypes._isFloat;
        isFunction: typeof IPrototypes._isFunction;
        isGenerator: typeof IPrototypes._isGenerator;
        isGeolocation: typeof IPrototypes._isGeolocation;
        isInt: typeof IPrototypes._isInt;
        isNull: typeof IPrototypes._isNullOrEmpty;
        isNullOrEmpty: typeof IPrototypes._isNullOrEmpty;
        isNumber: typeof IPrototypes._isNumber;
        isObject: typeof IPrototypes._isObject;
        isPromise: typeof IPrototypes._isPromise;
        isRegExp: typeof IPrototypes._isRegExp;
        isString: typeof IPrototypes._isString;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        absolutePath: typeof IAbsolutePath.default;
        ajax: typeof IAjax.default;
        noop: typeof INoop.default;
        catchAll: typeof ICatchAll.default;
        clusterit: typeof IClusterit.default;
        cuid: typeof ICuid.default;
        exclude: typeof IExclude.default;
        md5: typeof IMd5.default;
        wait: typeof IWait.default;
        JSZip: typeof IJSZip.default;
        zipit: typeof IZipit.default;
        clearCache: typeof IClearCache.default;
        cout: typeof ICout.default;
        foo: typeof IFoo.default;
        logit: typeof ILogit.default;
        include: typeof IInclude.default;
        mkdirRecursive: typeof IMkdirRecursive.default;
        namespace: typeof INamespace.default;
        now: typeof INow.default;
        parseBoolean: typeof IParseBoolean.default;
        parseRaw: typeof IParseRaw.default;
        rand: typeof IRand.default;
        randomIndex: typeof IRandomIndex.default;
        requireDirectory: typeof IRequireDirectory.default;
        runFuncArray: typeof IRunFuncArray.default;
        suid: typeof ISuid.default;
        syncroit: typeof ISyncroit.default;
        tryEval: typeof ITryEval.default;
    }
    //#region proto
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}


declare global {
    interface Craydent {
        xmlToJson: typeof IXmlToJson.default;
    }
    //#region proto
    interface String {
        xmlToJson: typeof IPrototypes._xmlToJson;
    }
    interface XMLDocument {
        xmlToJson: typeof IPrototypes._xmlToJson;
    }
    interface RegExp {
        xmlToJson: typeof IPrototypes._xmlToJson;
    }
    module NodeJS {
        interface Global {
            $c: Craydent;
        }
    }
    interface Window {
        $c: Craydent;
    }
    var $c: Craydent;
    //#endregion proto
    
}
declare const craydent: Craydent;
export = craydent;