text: var crypto = require('crypto');
  function TableView(__SLAG_PROPERTIES) {
  	__SLAG_PROPERTIES = __SLAG_PROPERTIES || {};
  	var __SLAG_DEVICE = JSON.parse(process.env.SLAG_DEVICE);
  	var __SLAG_CHECKS = [], __SLAG_NAMES = [
  			'accessibilityHidden',
  			'accessibilityHint',
  			'accessibilityLabel',
  			'accessibilityValue',
  			'allowsSelection',
  			'allowsSelectionDuringEditing',
  			'anchorPoint',
  			'animatedCenter',
  			'apiName',
  			'backgroundColor',
  			'backgroundDisabledColor',
  			'backgroundDisabledImage',
  			'backgroundFocusedColor',
  			'backgroundFocusedImage',
  			'backgroundGradient',
  			'backgroundImage',
  			'backgroundLeftCap',
  			'backgroundRepeat',
  			'backgroundTopCap',
  			'borderColor',
  			'borderRadius',
  			'borderWidth',
  			'bottom',
  			'bubbleParent',
  			'center',
  			'children',
  			'clipMode',
  			'data',
  			'editable',
  			'editing',
  			'filterAnchored',
  			'filterAttribute',
  			'filterCaseInsensitive',
  			'focusable',
  			'footerDividersEnabled',
  			'footerTitle',
  			'footerView',
  			'headerDividersEnabled',
  			'headerPullView',
  			'headerTitle',
  			'headerView',
  			'height',
  			'hideSearchOnSelection',
  			'horizontalWrap',
  			'index',
  			'keepScreenOn',
  			'layout',
  			'left',
  			'lifecycleContainer',
  			'maxRowHeight',
  			'minRowHeight',
  			'moveable',
  			'moving',
  			'opacity',
  			'overScrollMode',
  			'overrideCurrentAnimation',
  			'pullBackgroundColor',
  			'rect',
  			'refreshControl',
  			'right',
  			'rowHeight',
  			'scrollIndicatorStyle',
  			'scrollable',
  			'scrollsToTop',
  			'search',
  			'searchAsChild',
  			'searchHidden',
  			'sectionCount',
  			'sections',
  			'separatorColor',
  			'separatorInsets',
  			'separatorStyle',
  			'showVerticalScrollIndicator',
  			'size',
  			'softKeyboardOnFocus',
  			'style',
  			'tintColor',
  			'top',
  			'touchEnabled',
  			'transform',
  			'viewShadowColor',
  			'viewShadowOffset',
  			'viewShadowRadius',
  			'visible',
  			'width',
  			'zIndex',
  			'id'
  		];
  	if (__SLAG_NAMES.length > 0 && process.env.SLAG_STRICT === 'true') {
  		for (var __SLAG_NAME in __SLAG_PROPERTIES) {
  			if (__SLAG_NAMES.indexOf(__SLAG_NAME) === -1) {
  				throw new Error('Use user custom property ' + __SLAG_NAME);
  			}
  		}
  	} else if (__SLAG_NAMES.length === 0 && __SLAG_PROPERTIES.length > 0 && process.env.SLAG_STRICT === 'true') {
  		throw new Error('Use user custom properties. ' + __SLAG_PROPERTIES.join(', '));
  	}
  	var md5 = crypto.createHash('md5');
  	md5.update(crypto.randomBytes(32), 'binary');
  	this.__SLAG_ID = md5.digest('hex');
  	this.__SLAG_PARENT;
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.accessibilityHidden = undefined;
  	} else {
  		this.accessibilityHidden = __SLAG_PROPERTIES.accessibilityHidden || true;
  	}
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.accessibilityHint = undefined;
  	} else {
  		this.accessibilityHint = __SLAG_PROPERTIES.accessibilityHint || '';
  	}
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.accessibilityLabel = undefined;
  	} else {
  		this.accessibilityLabel = __SLAG_PROPERTIES.accessibilityLabel || '';
  	}
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.accessibilityValue = undefined;
  	} else {
  		this.accessibilityValue = __SLAG_PROPERTIES.accessibilityValue || '';
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.allowsSelection = undefined;
  	} else {
  		this.allowsSelection = __SLAG_PROPERTIES.allowsSelection || true;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.allowsSelectionDuringEditing = undefined;
  	} else {
  		this.allowsSelectionDuringEditing = __SLAG_PROPERTIES.allowsSelectionDuringEditing || true;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.anchorPoint = undefined;
  	} else {
  		this.anchorPoint = __SLAG_PROPERTIES.anchorPoint || {
  			x: 0,
  			y: 0
  		};
  	}
  	if (__SLAG_PROPERTIES.animatedCenter) {
  		throw new Error('Ti.UI.TableView.animatedCenter is read only property');
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.animatedCenter = undefined;
  	} else {
  		this.animatedCenter = {
  			x: 0,
  			y: 0
  		};
  	}
  	if (__SLAG_PROPERTIES.apiName) {
  		throw new Error('Ti.UI.TableView.apiName is read only property');
  	}
  	this.apiName = 'Ti.UI.TableView';
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.backgroundColor = undefined;
  	} else {
  		this.backgroundColor = __SLAG_PROPERTIES.backgroundColor || '';
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.backgroundDisabledColor = undefined;
  	} else {
  		this.backgroundDisabledColor = __SLAG_PROPERTIES.backgroundDisabledColor || '';
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.backgroundDisabledImage = undefined;
  	} else {
  		this.backgroundDisabledImage = __SLAG_PROPERTIES.backgroundDisabledImage || '';
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.backgroundFocusedColor = undefined;
  	} else {
  		this.backgroundFocusedColor = __SLAG_PROPERTIES.backgroundFocusedColor || '';
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.backgroundFocusedImage = undefined;
  	} else {
  		this.backgroundFocusedImage = __SLAG_PROPERTIES.backgroundFocusedImage || '';
  	}
  	if ([
  			'ios',
  			'mobileweb',
  			'android'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.backgroundGradient = undefined;
  	} else {
  		this.backgroundGradient = __SLAG_PROPERTIES.backgroundGradient || {};
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.backgroundImage = undefined;
  	} else {
  		this.backgroundImage = __SLAG_PROPERTIES.backgroundImage || '';
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.backgroundLeftCap = undefined;
  	} else {
  		this.backgroundLeftCap = __SLAG_PROPERTIES.backgroundLeftCap || 0;
  	}
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.backgroundRepeat = undefined;
  	} else {
  		this.backgroundRepeat = __SLAG_PROPERTIES.backgroundRepeat || true;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.backgroundTopCap = undefined;
  	} else {
  		this.backgroundTopCap = __SLAG_PROPERTIES.backgroundTopCap || 0;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.borderColor = undefined;
  	} else {
  		this.borderColor = __SLAG_PROPERTIES.borderColor || '';
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.borderRadius = undefined;
  	} else {
  		this.borderRadius = __SLAG_PROPERTIES.borderRadius || 0;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.borderWidth = undefined;
  	} else {
  		this.borderWidth = __SLAG_PROPERTIES.borderWidth || 0;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.bottom = undefined;
  	} else {
  		this.bottom = __SLAG_PROPERTIES.bottom || 0;
  	}
  	if ([
  			'ios',
  			'android'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.bubbleParent = undefined;
  	} else {
  		this.bubbleParent = __SLAG_PROPERTIES.bubbleParent || true;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.center = undefined;
  	} else {
  		this.center = __SLAG_PROPERTIES.center || {
  			x: 0,
  			y: 0
  		};
  	}
  	if (__SLAG_PROPERTIES.children) {
  		throw new Error('Ti.UI.TableView.children is read only property');
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.children = undefined;
  	} else {
  		this.children = [];
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.clipMode = undefined;
  	} else {
  		this.clipMode = __SLAG_PROPERTIES.clipMode || 0;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.data = undefined;
  	} else {
  		this.data = __SLAG_PROPERTIES.data || {};
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.editable = undefined;
  	} else {
  		this.editable = __SLAG_PROPERTIES.editable || true;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.editing = undefined;
  	} else {
  		this.editing = __SLAG_PROPERTIES.editing || true;
  	}
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.filterAnchored = undefined;
  	} else {
  		this.filterAnchored = __SLAG_PROPERTIES.filterAnchored || true;
  	}
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.filterAttribute = undefined;
  	} else {
  		this.filterAttribute = __SLAG_PROPERTIES.filterAttribute || '';
  	}
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.filterCaseInsensitive = undefined;
  	} else {
  		this.filterCaseInsensitive = __SLAG_PROPERTIES.filterCaseInsensitive || true;
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.focusable = undefined;
  	} else {
  		this.focusable = __SLAG_PROPERTIES.focusable || true;
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.footerDividersEnabled = undefined;
  	} else {
  		this.footerDividersEnabled = __SLAG_PROPERTIES.footerDividersEnabled || true;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.footerTitle = undefined;
  	} else {
  		this.footerTitle = __SLAG_PROPERTIES.footerTitle || '';
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.footerView = undefined;
  	} else {
  		this.footerView = __SLAG_PROPERTIES.footerView || {};
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.headerDividersEnabled = undefined;
  	} else {
  		this.headerDividersEnabled = __SLAG_PROPERTIES.headerDividersEnabled || true;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.headerPullView = undefined;
  	} else {
  		this.headerPullView = __SLAG_PROPERTIES.headerPullView || {};
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.headerTitle = undefined;
  	} else {
  		this.headerTitle = __SLAG_PROPERTIES.headerTitle || '';
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.headerView = undefined;
  	} else {
  		this.headerView = __SLAG_PROPERTIES.headerView || {};
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.height = undefined;
  	} else {
  		this.height = __SLAG_PROPERTIES.height || 0;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.hideSearchOnSelection = undefined;
  	} else {
  		this.hideSearchOnSelection = __SLAG_PROPERTIES.hideSearchOnSelection || true;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.horizontalWrap = undefined;
  	} else {
  		this.horizontalWrap = __SLAG_PROPERTIES.horizontalWrap || true;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.index = undefined;
  	} else {
  		this.index = __SLAG_PROPERTIES.index || [];
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.keepScreenOn = undefined;
  	} else {
  		this.keepScreenOn = __SLAG_PROPERTIES.keepScreenOn || true;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.layout = undefined;
  	} else {
  		this.layout = __SLAG_PROPERTIES.layout || '';
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.left = undefined;
  	} else {
  		this.left = __SLAG_PROPERTIES.left || 0;
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.lifecycleContainer = undefined;
  	} else {
  		this.lifecycleContainer = __SLAG_PROPERTIES.lifecycleContainer || {};
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.maxRowHeight = undefined;
  	} else {
  		this.maxRowHeight = __SLAG_PROPERTIES.maxRowHeight || 0;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.minRowHeight = undefined;
  	} else {
  		this.minRowHeight = __SLAG_PROPERTIES.minRowHeight || 0;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.moveable = undefined;
  	} else {
  		this.moveable = __SLAG_PROPERTIES.moveable || true;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.moving = undefined;
  	} else {
  		this.moving = __SLAG_PROPERTIES.moving || true;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.opacity = undefined;
  	} else {
  		this.opacity = __SLAG_PROPERTIES.opacity || 0;
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.overScrollMode = undefined;
  	} else {
  		this.overScrollMode = __SLAG_PROPERTIES.overScrollMode || 0;
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.overrideCurrentAnimation = undefined;
  	} else {
  		this.overrideCurrentAnimation = __SLAG_PROPERTIES.overrideCurrentAnimation || true;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.pullBackgroundColor = undefined;
  	} else {
  		this.pullBackgroundColor = __SLAG_PROPERTIES.pullBackgroundColor || '';
  	}
  	if (__SLAG_PROPERTIES.rect) {
  		throw new Error('Ti.UI.TableView.rect is read only property');
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.rect = undefined;
  	} else {
  		this.rect = {
  			x: 0,
  			y: 0,
  			width: 0,
  			height: 0
  		};
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.refreshControl = undefined;
  	} else {
  		this.refreshControl = __SLAG_PROPERTIES.refreshControl || {};
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.right = undefined;
  	} else {
  		this.right = __SLAG_PROPERTIES.right || 0;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.rowHeight = undefined;
  	} else {
  		this.rowHeight = __SLAG_PROPERTIES.rowHeight || 0;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.scrollIndicatorStyle = undefined;
  	} else {
  		this.scrollIndicatorStyle = __SLAG_PROPERTIES.scrollIndicatorStyle || 0;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.scrollable = undefined;
  	} else {
  		this.scrollable = __SLAG_PROPERTIES.scrollable || true;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.scrollsToTop = undefined;
  	} else {
  		this.scrollsToTop = __SLAG_PROPERTIES.scrollsToTop || true;
  	}
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.search = undefined;
  	} else {
  		this.search = __SLAG_PROPERTIES.search || {};
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.searchAsChild = undefined;
  	} else {
  		this.searchAsChild = __SLAG_PROPERTIES.searchAsChild || true;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.searchHidden = undefined;
  	} else {
  		this.searchHidden = __SLAG_PROPERTIES.searchHidden || true;
  	}
  	if (__SLAG_PROPERTIES.sectionCount) {
  		throw new Error('Ti.UI.TableView.sectionCount is read only property');
  	}
  	if ([
  			'android',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.sectionCount = undefined;
  	} else {
  		this.sectionCount = 0;
  	}
  	if ([
  			'android',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.sections = undefined;
  	} else {
  		this.sections = __SLAG_PROPERTIES.sections || [];
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.separatorColor = undefined;
  	} else {
  		this.separatorColor = __SLAG_PROPERTIES.separatorColor || '';
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.separatorInsets = undefined;
  	} else {
  		this.separatorInsets = __SLAG_PROPERTIES.separatorInsets || {};
  	}
  	if ([
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.separatorStyle = undefined;
  	} else {
  		this.separatorStyle = __SLAG_PROPERTIES.separatorStyle || 0;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.showVerticalScrollIndicator = undefined;
  	} else {
  		this.showVerticalScrollIndicator = __SLAG_PROPERTIES.showVerticalScrollIndicator || true;
  	}
  	if (__SLAG_PROPERTIES.size) {
  		throw new Error('Ti.UI.TableView.size is read only property');
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.size = undefined;
  	} else {
  		this.size = {
  			x: 0,
  			y: 0,
  			width: 0,
  			height: 0
  		};
  	}
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.softKeyboardOnFocus = undefined;
  	} else {
  		this.softKeyboardOnFocus = __SLAG_PROPERTIES.softKeyboardOnFocus || 0;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.style = undefined;
  	} else {
  		this.style = __SLAG_PROPERTIES.style || 0;
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.tintColor = undefined;
  	} else {
  		this.tintColor = __SLAG_PROPERTIES.tintColor || '';
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.top = undefined;
  	} else {
  		this.top = __SLAG_PROPERTIES.top || 0;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.touchEnabled = undefined;
  	} else {
  		this.touchEnabled = __SLAG_PROPERTIES.touchEnabled || true;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.transform = undefined;
  	} else {
  		this.transform = __SLAG_PROPERTIES.transform || {};
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.viewShadowColor = undefined;
  	} else {
  		this.viewShadowColor = __SLAG_PROPERTIES.viewShadowColor || '';
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.viewShadowOffset = undefined;
  	} else {
  		this.viewShadowOffset = __SLAG_PROPERTIES.viewShadowOffset || {
  			x: 0,
  			y: 0
  		};
  	}
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.viewShadowRadius = undefined;
  	} else {
  		this.viewShadowRadius = __SLAG_PROPERTIES.viewShadowRadius || 0;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.visible = undefined;
  	} else {
  		this.visible = __SLAG_PROPERTIES.visible || true;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.width = undefined;
  	} else {
  		this.width = __SLAG_PROPERTIES.width || 0;
  	}
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		this.zIndex = undefined;
  	} else {
  		this.zIndex = __SLAG_PROPERTIES.zIndex || 0;
  	}
  	this.id = __SLAG_PROPERTIES.id || '';
  	return this;
  }
  TableView.prototype.add = function (__SLAG_PARAMETER) {
  	this.children.push(__SLAG_PARAMETER);
  	__SLAG_PARAMETER.__SLAG_PARENT = this;
  };
  TableView.prototype.addEventListener = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.animate = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.appendRow = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.appendSection = function () {
  	if ([
  			'android',
  			'mobileweb',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.applyProperties = function (__SLAG_PROPERTIES) {
  	for (var __SLAG_NAME in __SLAG_PROPERTIES) {
  		this[__SLAG_NAME] = __SLAG_PROPERTIES[__SLAG_NAME];
  	}
  };
  TableView.prototype.convertPointToView = function () {
  	if ([
  			'android',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return {
  		x: 0,
  		y: 0
  	};
  };
  TableView.prototype.deleteRow = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.deleteSection = function () {
  	if ([
  			'android',
  			'mobileweb',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.deselectRow = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.finishLayout = function () {
  	throw new Error('Ti.UI.TableView.finishLayout was deprecated, since 3.0.0');
  };
  TableView.prototype.fireEvent = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.getAccessibilityHidden = function () {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.accessibilityHidden;
  };
  TableView.prototype.getAccessibilityHint = function () {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.accessibilityHint;
  };
  TableView.prototype.getAccessibilityLabel = function () {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.accessibilityLabel;
  };
  TableView.prototype.getAccessibilityValue = function () {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.accessibilityValue;
  };
  TableView.prototype.getAllowsSelection = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.allowsSelection;
  };
  TableView.prototype.getAllowsSelectionDuringEditing = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.allowsSelectionDuringEditing;
  };
  TableView.prototype.getAnchorPoint = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.anchorPoint;
  };
  TableView.prototype.getAnimatedCenter = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.animatedCenter;
  };
  TableView.prototype.getApiName = function () {
  	if ([
  			'android',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.apiName;
  };
  TableView.prototype.getBackgroundColor = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.backgroundColor;
  };
  TableView.prototype.getBackgroundDisabledColor = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.backgroundDisabledColor;
  };
  TableView.prototype.getBackgroundDisabledImage = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.backgroundDisabledImage;
  };
  TableView.prototype.getBackgroundFocusedColor = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.backgroundFocusedColor;
  };
  TableView.prototype.getBackgroundFocusedImage = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.backgroundFocusedImage;
  };
  TableView.prototype.getBackgroundGradient = function () {
  	if ([
  			'ios',
  			'mobileweb',
  			'android'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.backgroundGradient;
  };
  TableView.prototype.getBackgroundImage = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.backgroundImage;
  };
  TableView.prototype.getBackgroundLeftCap = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.backgroundLeftCap;
  };
  TableView.prototype.getBackgroundRepeat = function () {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.backgroundRepeat;
  };
  TableView.prototype.getBackgroundTopCap = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.backgroundTopCap;
  };
  TableView.prototype.getBorderColor = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.borderColor;
  };
  TableView.prototype.getBorderRadius = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.borderRadius;
  };
  TableView.prototype.getBorderWidth = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.borderWidth;
  };
  TableView.prototype.getBottom = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.bottom;
  };
  TableView.prototype.getBubbleParent = function () {
  	if ([
  			'ios',
  			'android'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.bubbleParent;
  };
  TableView.prototype.getCenter = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.center;
  };
  TableView.prototype.getParent = function () {
  	return this.__SLAG_PARENT;
  };
  TableView.prototype.getChildren = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.children;
  };
  TableView.prototype.getClipMode = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.clipMode;
  };
  TableView.prototype.getData = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.data;
  };
  TableView.prototype.getEditable = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.editable;
  };
  TableView.prototype.getEditing = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.editing;
  };
  TableView.prototype.getFilterAnchored = function () {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.filterAnchored;
  };
  TableView.prototype.getFilterAttribute = function () {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.filterAttribute;
  };
  TableView.prototype.getFilterCaseInsensitive = function () {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.filterCaseInsensitive;
  };
  TableView.prototype.getFocusable = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.focusable;
  };
  TableView.prototype.getFooterDividersEnabled = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.footerDividersEnabled;
  };
  TableView.prototype.getFooterTitle = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.footerTitle;
  };
  TableView.prototype.getFooterView = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.footerView;
  };
  TableView.prototype.getHeaderDividersEnabled = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.headerDividersEnabled;
  };
  TableView.prototype.getHeaderPullView = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.headerPullView;
  };
  TableView.prototype.getHeaderTitle = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.headerTitle;
  };
  TableView.prototype.getHeaderView = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.headerView;
  };
  TableView.prototype.getHeight = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.height;
  };
  TableView.prototype.getHideSearchOnSelection = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.hideSearchOnSelection;
  };
  TableView.prototype.getHorizontalWrap = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.horizontalWrap;
  };
  TableView.prototype.getIndex = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.index;
  };
  TableView.prototype.getKeepScreenOn = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.keepScreenOn;
  };
  TableView.prototype.getLayout = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.layout;
  };
  TableView.prototype.getLeft = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.left;
  };
  TableView.prototype.getLifecycleContainer = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.lifecycleContainer;
  };
  TableView.prototype.getMaxRowHeight = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.maxRowHeight;
  };
  TableView.prototype.getMinRowHeight = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.minRowHeight;
  };
  TableView.prototype.getMoveable = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.moveable;
  };
  TableView.prototype.getMoving = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.moving;
  };
  TableView.prototype.getOpacity = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.opacity;
  };
  TableView.prototype.getOverScrollMode = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.overScrollMode;
  };
  TableView.prototype.getOverrideCurrentAnimation = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.overrideCurrentAnimation;
  };
  TableView.prototype.getPullBackgroundColor = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.pullBackgroundColor;
  };
  TableView.prototype.getRect = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.rect;
  };
  TableView.prototype.getRefreshControl = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.refreshControl;
  };
  TableView.prototype.getRight = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.right;
  };
  TableView.prototype.getRowHeight = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.rowHeight;
  };
  TableView.prototype.getScrollIndicatorStyle = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.scrollIndicatorStyle;
  };
  TableView.prototype.getScrollable = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.scrollable;
  };
  TableView.prototype.getScrollsToTop = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.scrollsToTop;
  };
  TableView.prototype.getSearch = function () {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.search;
  };
  TableView.prototype.getSearchAsChild = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.searchAsChild;
  };
  TableView.prototype.getSearchHidden = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.searchHidden;
  };
  TableView.prototype.getSectionCount = function () {
  	if ([
  			'android',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.sectionCount;
  };
  TableView.prototype.getSections = function () {
  	if ([
  			'android',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.sections;
  };
  TableView.prototype.getSeparatorColor = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.separatorColor;
  };
  TableView.prototype.getSeparatorInsets = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.separatorInsets;
  };
  TableView.prototype.getSeparatorStyle = function () {
  	if ([
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.separatorStyle;
  };
  TableView.prototype.getShowVerticalScrollIndicator = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.showVerticalScrollIndicator;
  };
  TableView.prototype.getSize = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.size;
  };
  TableView.prototype.getSoftKeyboardOnFocus = function () {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.softKeyboardOnFocus;
  };
  TableView.prototype.getStyle = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.style;
  };
  TableView.prototype.getTintColor = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.tintColor;
  };
  TableView.prototype.getTop = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.top;
  };
  TableView.prototype.getTouchEnabled = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.touchEnabled;
  };
  TableView.prototype.getTransform = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.transform;
  };
  TableView.prototype.getViewShadowColor = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.viewShadowColor;
  };
  TableView.prototype.getViewShadowOffset = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.viewShadowOffset;
  };
  TableView.prototype.getViewShadowRadius = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.viewShadowRadius;
  };
  TableView.prototype.getVisible = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.visible;
  };
  TableView.prototype.getWidth = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.width;
  };
  TableView.prototype.getZIndex = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return this.zIndex;
  };
  TableView.prototype.hide = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.insertRowAfter = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.insertRowBefore = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.insertSectionAfter = function () {
  	if ([
  			'android',
  			'mobileweb',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.insertSectionBefore = function () {
  	if ([
  			'android',
  			'mobileweb',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.remove = function (__SLAG_PARAMETER) {
  	for (var __SLAG_COUNTER = 0; __SLAG_COUNTER < this.children.length; __SLAG_COUNTER++) {
  		if (this.children[__SLAG_COUNTER].__SLAG_ID === __SLAG_PARAMETER.__SLAG_ID) {
  			this.children.splice(__SLAG_COUNTER, 1);
  			break;
  		}
  	}
  	__SLAG_PARAMETER.__SLAG_PARENT = undefined;
  };
  TableView.prototype.removeAllChildren = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.removeEventListener = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.scrollToIndex = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.scrollToTop = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.selectRow = function () {
  	if ([
  			'ios',
  			'android'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.setAccessibilityHidden = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.accessibilityHidden = __SLAG__PROPERTY;
  };
  TableView.prototype.setAccessibilityHint = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.accessibilityHint = __SLAG__PROPERTY;
  };
  TableView.prototype.setAccessibilityLabel = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.accessibilityLabel = __SLAG__PROPERTY;
  };
  TableView.prototype.setAccessibilityValue = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.accessibilityValue = __SLAG__PROPERTY;
  };
  TableView.prototype.setAllowsSelection = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.allowsSelection = __SLAG__PROPERTY;
  };
  TableView.prototype.setAllowsSelectionDuringEditing = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.allowsSelectionDuringEditing = __SLAG__PROPERTY;
  };
  TableView.prototype.setAnchorPoint = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.anchorPoint = __SLAG__PROPERTY;
  };
  TableView.prototype.setBackgroundColor = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.backgroundColor = __SLAG__PROPERTY;
  };
  TableView.prototype.setBackgroundDisabledColor = function (__SLAG__PROPERTY) {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.backgroundDisabledColor = __SLAG__PROPERTY;
  };
  TableView.prototype.setBackgroundDisabledImage = function (__SLAG__PROPERTY) {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.backgroundDisabledImage = __SLAG__PROPERTY;
  };
  TableView.prototype.setBackgroundFocusedColor = function (__SLAG__PROPERTY) {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.backgroundFocusedColor = __SLAG__PROPERTY;
  };
  TableView.prototype.setBackgroundFocusedImage = function (__SLAG__PROPERTY) {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.backgroundFocusedImage = __SLAG__PROPERTY;
  };
  TableView.prototype.setBackgroundGradient = function (__SLAG__PROPERTY) {
  	if ([
  			'ios',
  			'mobileweb',
  			'android'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.backgroundGradient = __SLAG__PROPERTY;
  };
  TableView.prototype.setBackgroundImage = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.backgroundImage = __SLAG__PROPERTY;
  };
  TableView.prototype.setBackgroundLeftCap = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.backgroundLeftCap = __SLAG__PROPERTY;
  };
  TableView.prototype.setBackgroundRepeat = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.backgroundRepeat = __SLAG__PROPERTY;
  };
  TableView.prototype.setBackgroundTopCap = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.backgroundTopCap = __SLAG__PROPERTY;
  };
  TableView.prototype.setBorderColor = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.borderColor = __SLAG__PROPERTY;
  };
  TableView.prototype.setBorderRadius = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.borderRadius = __SLAG__PROPERTY;
  };
  TableView.prototype.setBorderWidth = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.borderWidth = __SLAG__PROPERTY;
  };
  TableView.prototype.setBottom = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.bottom = __SLAG__PROPERTY;
  };
  TableView.prototype.setBubbleParent = function (__SLAG__PROPERTY) {
  	if ([
  			'ios',
  			'android'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.bubbleParent = __SLAG__PROPERTY;
  };
  TableView.prototype.setCenter = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.center = __SLAG__PROPERTY;
  };
  TableView.prototype.setClipMode = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.clipMode = __SLAG__PROPERTY;
  };
  TableView.prototype.setContentInsets = function () {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.setData = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.data = __SLAG__PROPERTY;
  };
  TableView.prototype.setEditable = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.editable = __SLAG__PROPERTY;
  };
  TableView.prototype.setEditing = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.editing = __SLAG__PROPERTY;
  };
  TableView.prototype.setFilterAnchored = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.filterAnchored = __SLAG__PROPERTY;
  };
  TableView.prototype.setFilterAttribute = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.filterAttribute = __SLAG__PROPERTY;
  };
  TableView.prototype.setFilterCaseInsensitive = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.filterCaseInsensitive = __SLAG__PROPERTY;
  };
  TableView.prototype.setFocusable = function (__SLAG__PROPERTY) {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.focusable = __SLAG__PROPERTY;
  };
  TableView.prototype.setFooterTitle = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.footerTitle = __SLAG__PROPERTY;
  };
  TableView.prototype.setFooterView = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.footerView = __SLAG__PROPERTY;
  };
  TableView.prototype.setHeaderPullView = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.headerPullView = __SLAG__PROPERTY;
  };
  TableView.prototype.setHeaderTitle = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.headerTitle = __SLAG__PROPERTY;
  };
  TableView.prototype.setHeaderView = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.headerView = __SLAG__PROPERTY;
  };
  TableView.prototype.setHeight = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.height = __SLAG__PROPERTY;
  };
  TableView.prototype.setHideSearchOnSelection = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.hideSearchOnSelection = __SLAG__PROPERTY;
  };
  TableView.prototype.setHorizontalWrap = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.horizontalWrap = __SLAG__PROPERTY;
  };
  TableView.prototype.setIndex = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.index = __SLAG__PROPERTY;
  };
  TableView.prototype.setKeepScreenOn = function (__SLAG__PROPERTY) {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.keepScreenOn = __SLAG__PROPERTY;
  };
  TableView.prototype.setLayout = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.layout = __SLAG__PROPERTY;
  };
  TableView.prototype.setLeft = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.left = __SLAG__PROPERTY;
  };
  TableView.prototype.setLifecycleContainer = function (__SLAG__PROPERTY) {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.lifecycleContainer = __SLAG__PROPERTY;
  };
  TableView.prototype.setMaxRowHeight = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.maxRowHeight = __SLAG__PROPERTY;
  };
  TableView.prototype.setMinRowHeight = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.minRowHeight = __SLAG__PROPERTY;
  };
  TableView.prototype.setMoveable = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.moveable = __SLAG__PROPERTY;
  };
  TableView.prototype.setMoving = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.moving = __SLAG__PROPERTY;
  };
  TableView.prototype.setOpacity = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.opacity = __SLAG__PROPERTY;
  };
  TableView.prototype.setOverScrollMode = function (__SLAG__PROPERTY) {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.overScrollMode = __SLAG__PROPERTY;
  };
  TableView.prototype.setPullBackgroundColor = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.pullBackgroundColor = __SLAG__PROPERTY;
  };
  TableView.prototype.setRefreshControl = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.refreshControl = __SLAG__PROPERTY;
  };
  TableView.prototype.setRight = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.right = __SLAG__PROPERTY;
  };
  TableView.prototype.setRowHeight = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.rowHeight = __SLAG__PROPERTY;
  };
  TableView.prototype.setScrollIndicatorStyle = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.scrollIndicatorStyle = __SLAG__PROPERTY;
  };
  TableView.prototype.setScrollable = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.scrollable = __SLAG__PROPERTY;
  };
  TableView.prototype.setScrollsToTop = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.scrollsToTop = __SLAG__PROPERTY;
  };
  TableView.prototype.setSearch = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.search = __SLAG__PROPERTY;
  };
  TableView.prototype.setSearchAsChild = function (__SLAG__PROPERTY) {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.searchAsChild = __SLAG__PROPERTY;
  };
  TableView.prototype.setSearchHidden = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.searchHidden = __SLAG__PROPERTY;
  };
  TableView.prototype.setSections = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.sections = __SLAG__PROPERTY;
  };
  TableView.prototype.setSeparatorColor = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.separatorColor = __SLAG__PROPERTY;
  };
  TableView.prototype.setSeparatorInsets = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.separatorInsets = __SLAG__PROPERTY;
  };
  TableView.prototype.setSeparatorStyle = function (__SLAG__PROPERTY) {
  	if ([
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.separatorStyle = __SLAG__PROPERTY;
  };
  TableView.prototype.setShowVerticalScrollIndicator = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.showVerticalScrollIndicator = __SLAG__PROPERTY;
  };
  TableView.prototype.setSoftKeyboardOnFocus = function (__SLAG__PROPERTY) {
  	if (['android'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.softKeyboardOnFocus = __SLAG__PROPERTY;
  };
  TableView.prototype.setStyle = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.style = __SLAG__PROPERTY;
  };
  TableView.prototype.setTintColor = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.tintColor = __SLAG__PROPERTY;
  };
  TableView.prototype.setTop = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.top = __SLAG__PROPERTY;
  };
  TableView.prototype.setTouchEnabled = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.touchEnabled = __SLAG__PROPERTY;
  };
  TableView.prototype.setTransform = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.transform = __SLAG__PROPERTY;
  };
  TableView.prototype.setViewShadowColor = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.viewShadowColor = __SLAG__PROPERTY;
  };
  TableView.prototype.setViewShadowOffset = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.viewShadowOffset = __SLAG__PROPERTY;
  };
  TableView.prototype.setViewShadowRadius = function (__SLAG__PROPERTY) {
  	if (['ios'].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.viewShadowRadius = __SLAG__PROPERTY;
  };
  TableView.prototype.setVisible = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.visible = __SLAG__PROPERTY;
  };
  TableView.prototype.setWidth = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.width = __SLAG__PROPERTY;
  };
  TableView.prototype.setZIndex = function (__SLAG__PROPERTY) {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	this.zIndex = __SLAG__PROPERTY;
  };
  TableView.prototype.show = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.startLayout = function () {
  	throw new Error('Ti.UI.TableView.startLayout was deprecated, since 3.0.0');
  };
  TableView.prototype.toImage = function () {
  	if ([
  			'android',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  	return {};
  };
  TableView.prototype.updateLayout = function () {
  	throw new Error('Ti.UI.TableView.updateLayout was deprecated, since 3.0.0');
  };
  TableView.prototype.updateRow = function () {
  	if ([
  			'android',
  			'blackberry',
  			'ios',
  			'mobileweb'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  TableView.prototype.updateSection = function () {
  	if ([
  			'android',
  			'mobileweb',
  			'ios'
  		].indexOf(process.env.SLAG_PLATFORM) === -1) {
  		throw new Error('This method is not support specified platform');
  	}
  };
  module.exports = function (properties) {
  	return new TableView(properties);
  };