<?php

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 3.0.12
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */

// Try to load our extension if it's not already loaded.
if (!extension_loaded('chilkat')) {
  if (strtolower(substr(PHP_OS, 0, 3)) === 'win') {
    if (!dl('php_chilkat.dll')) return;
  } else {
    // PHP_SHLIB_SUFFIX gives 'dylib' on MacOS X but modules are 'so'.
    if (PHP_SHLIB_SUFFIX === 'dylib') {
      if (!dl('chilkat.so')) return;
    } else {
      if (!dl('chilkat.'.PHP_SHLIB_SUFFIX)) return;
    }
  }
}



abstract class chilkat {
	static function _ck_nullptr_error_set($_ck_nullptr_error) {
		_ck_nullptr_error_set($_ck_nullptr_error);
	}

	static function _ck_nullptr_error_get() {
		return _ck_nullptr_error_get();
	}

	static function _ck_type_error_msg_set($_ck_type_error_msg) {
		_ck_type_error_msg_set($_ck_type_error_msg);
	}

	static function _ck_type_error_msg_get() {
		return _ck_type_error_msg_get();
	}

	static function _ckReturnByteData($z,$s,$l) {
		_ckReturnByteData($z,$s,$l);
	}
}

/* PHP Proxy Classes */
class CkBaseProgress {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkBaseProgress') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkBaseProgress();
	}

	function AbortCheck() {
		return CkBaseProgress_AbortCheck($this->_cPtr);
	}

	function PercentDone($pctDone) {
		return CkBaseProgress_PercentDone($this->_cPtr,$pctDone);
	}

	function ProgressInfo($name,$value) {
		CkBaseProgress_ProgressInfo($this->_cPtr,$name,$value);
	}

	function TaskCompleted($task) {
		CkBaseProgress_TaskCompleted($this->_cPtr,$task);
	}

	function TextData($data) {
		CkBaseProgress_TextData($this->_cPtr,$data);
	}
}

class CkSFtpProgress extends CkBaseProgress {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		CkBaseProgress::__set($var,$value);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return CkBaseProgress::__get($var);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return CkBaseProgress::__isset($var);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSFtpProgress') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSFtpProgress();
	}
}

class CkMailManProgress extends CkBaseProgress {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		CkBaseProgress::__set($var,$value);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return CkBaseProgress::__get($var);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return CkBaseProgress::__isset($var);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkMailManProgress') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkMailManProgress();
	}

	function EmailReceived($subject,$fromAddr,$fromName,$returnPath,$date,$uidl,$sizeInBytes) {
		CkMailManProgress_EmailReceived($this->_cPtr,$subject,$fromAddr,$fromName,$returnPath,$date,$uidl,$sizeInBytes);
	}
}

class CkHttpProgress extends CkBaseProgress {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		CkBaseProgress::__set($var,$value);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return CkBaseProgress::__get($var);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return CkBaseProgress::__isset($var);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkHttpProgress') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkHttpProgress();
	}

	function HttpRedirect($originalUrl,$redirectUrl) {
		return CkHttpProgress_HttpRedirect($this->_cPtr,$originalUrl,$redirectUrl);
	}

	function HttpChunked() {
		CkHttpProgress_HttpChunked($this->_cPtr);
	}

	function HttpBeginReceive() {
		CkHttpProgress_HttpBeginReceive($this->_cPtr);
	}

	function HttpEndReceive($success) {
		CkHttpProgress_HttpEndReceive($this->_cPtr,$success);
	}

	function HttpBeginSend() {
		CkHttpProgress_HttpBeginSend($this->_cPtr);
	}

	function HttpEndSend($success) {
		CkHttpProgress_HttpEndSend($this->_cPtr,$success);
	}
}

class CkFtp2Progress extends CkBaseProgress {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		CkBaseProgress::__set($var,$value);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return CkBaseProgress::__get($var);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return CkBaseProgress::__isset($var);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkFtp2Progress') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkFtp2Progress();
	}

	function BeginDownloadFile($pathUtf8) {
		return CkFtp2Progress_BeginDownloadFile($this->_cPtr,$pathUtf8);
	}

	function VerifyDownloadDir($pathUtf8) {
		return CkFtp2Progress_VerifyDownloadDir($this->_cPtr,$pathUtf8);
	}

	function BeginUploadFile($pathUtf8) {
		return CkFtp2Progress_BeginUploadFile($this->_cPtr,$pathUtf8);
	}

	function VerifyUploadDir($pathUtf8) {
		return CkFtp2Progress_VerifyUploadDir($this->_cPtr,$pathUtf8);
	}

	function VerifyDeleteDir($pathUtf8) {
		return CkFtp2Progress_VerifyDeleteDir($this->_cPtr,$pathUtf8);
	}

	function VerifyDeleteFile($pathUtf8) {
		return CkFtp2Progress_VerifyDeleteFile($this->_cPtr,$pathUtf8);
	}
}

class CkZipProgress extends CkBaseProgress {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		CkBaseProgress::__set($var,$value);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return CkBaseProgress::__get($var);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return CkBaseProgress::__isset($var);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkZipProgress') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkZipProgress();
	}

	function DirToBeAdded($filePath) {
		return CkZipProgress_DirToBeAdded($this->_cPtr,$filePath);
	}

	function AddFilesBegin() {
		CkZipProgress_AddFilesBegin($this->_cPtr);
	}

	function AddFilesEnd() {
		CkZipProgress_AddFilesEnd($this->_cPtr);
	}

	function WriteZipBegin() {
		CkZipProgress_WriteZipBegin($this->_cPtr);
	}

	function WriteZipEnd() {
		CkZipProgress_WriteZipEnd($this->_cPtr);
	}

	function UnzipBegin() {
		CkZipProgress_UnzipBegin($this->_cPtr);
	}

	function UnzipEnd() {
		CkZipProgress_UnzipEnd($this->_cPtr);
	}
}

class CkTarProgress extends CkBaseProgress {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		CkBaseProgress::__set($var,$value);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return CkBaseProgress::__get($var);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return CkBaseProgress::__isset($var);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkTarProgress') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkTarProgress();
	}
}

class CkString {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkString') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkString();
	}

	function get_Utf8() {
		return CkString_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkString_put_Utf8($this->_cPtr,$b);
	}

	function get_NumArabic() {
		return CkString_get_NumArabic($this->_cPtr);
	}

	function get_NumAscii() {
		return CkString_get_NumAscii($this->_cPtr);
	}

	function get_NumCentralEuro() {
		return CkString_get_NumCentralEuro($this->_cPtr);
	}

	function get_NumChinese() {
		return CkString_get_NumChinese($this->_cPtr);
	}

	function get_NumCyrillic() {
		return CkString_get_NumCyrillic($this->_cPtr);
	}

	function get_NumGreek() {
		return CkString_get_NumGreek($this->_cPtr);
	}

	function get_NumHebrew() {
		return CkString_get_NumHebrew($this->_cPtr);
	}

	function get_NumJapanese() {
		return CkString_get_NumJapanese($this->_cPtr);
	}

	function get_NumKorean() {
		return CkString_get_NumKorean($this->_cPtr);
	}

	function get_NumLatin() {
		return CkString_get_NumLatin($this->_cPtr);
	}

	function get_NumThai() {
		return CkString_get_NumThai($this->_cPtr);
	}

	function loadFile($fileName,$charset) {
		return CkString_loadFile($this->_cPtr,$fileName,$charset);
	}

	function charAt($idx) {
		return CkString_charAt($this->_cPtr,$idx);
	}

	function intValue() {
		return CkString_intValue($this->_cPtr);
	}

	function doubleValue() {
		return CkString_doubleValue($this->_cPtr);
	}

	function c_clone() {
		$r=CkString_c_clone($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkString($r);
		}
		return $r;
	}

	function countCharOccurances($ch) {
		return CkString_countCharOccurances($this->_cPtr,$ch);
	}

	function appendCurrentDateRfc822() {
		CkString_appendCurrentDateRfc822($this->_cPtr);
	}

	function removeDelimited($beginDelim,$endDelim,$caseSensitive) {
		CkString_removeDelimited($this->_cPtr,$beginDelim,$endDelim,$caseSensitive);
	}

	function setStr($s) {
		CkString_setStr($this->_cPtr,$s);
	}

	function endsWith($s) {
		return CkString_endsWith($this->_cPtr,$s);
	}

	function endsWithStr($s) {
		return CkString_endsWithStr($this->_cPtr,$s);
	}

	function beginsWithStr($s) {
		return CkString_beginsWithStr($this->_cPtr,$s);
	}

	function indexOf($s) {
		return CkString_indexOf($this->_cPtr,$s);
	}

	function indexOfStr($s) {
		return CkString_indexOfStr($this->_cPtr,$s);
	}

	function replaceAll($str,$replacement) {
		return CkString_replaceAll($this->_cPtr,$str,$replacement);
	}

	function replaceFirst($str,$replacement) {
		return CkString_replaceFirst($this->_cPtr,$str,$replacement);
	}

	function substring($startCharIdx,$numChars) {
		$r=CkString_substring($this->_cPtr,$startCharIdx,$numChars);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkString($r);
		}
		return $r;
	}

	function matchesStr($str) {
		return CkString_matchesStr($this->_cPtr,$str);
	}

	function matches($s) {
		return CkString_matches($this->_cPtr,$s);
	}

	function getChar($idx) {
		$r=CkString_getChar($this->_cPtr,$idx);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkString($r);
		}
		return $r;
	}

	function removeAll($str) {
		return CkString_removeAll($this->_cPtr,$str);
	}

	function removeFirst($str) {
		return CkString_removeFirst($this->_cPtr,$str);
	}

	function chopAtStr($str) {
		CkString_chopAtStr($this->_cPtr,$str);
	}

	function urlDecode($charset) {
		CkString_urlDecode($this->_cPtr,$charset);
	}

	function urlEncode($charset) {
		CkString_urlEncode($this->_cPtr,$charset);
	}

	function base64Decode($charset) {
		CkString_base64Decode($this->_cPtr,$charset);
	}

	function base64Encode($charset) {
		CkString_base64Encode($this->_cPtr,$charset);
	}

	function qpDecode($charset) {
		CkString_qpDecode($this->_cPtr,$charset);
	}

	function qpEncode($charset) {
		CkString_qpEncode($this->_cPtr,$charset);
	}

	function hexDecode($charset) {
		CkString_hexDecode($this->_cPtr,$charset);
	}

	function hexEncode($charset) {
		CkString_hexEncode($this->_cPtr,$charset);
	}

	function entityDecode() {
		CkString_entityDecode($this->_cPtr);
	}

	function entityEncode() {
		CkString_entityEncode($this->_cPtr);
	}

	function appendUtf8($s) {
		CkString_appendUtf8($this->_cPtr,$s);
	}

	function appendAnsi($s) {
		CkString_appendAnsi($this->_cPtr,$s);
	}

	function clear() {
		CkString_clear($this->_cPtr);
	}

	function prepend($s) {
		CkString_prepend($this->_cPtr,$s);
	}

	function appendInt($n) {
		CkString_appendInt($this->_cPtr,$n);
	}

	function append($s) {
		CkString_append($this->_cPtr,$s);
	}

	function appendChar($c_) {
		CkString_appendChar($this->_cPtr,$c_);
	}

	function appendN($s,$numBytes) {
		CkString_appendN($this->_cPtr,$s,$numBytes);
	}

	function appendStr($str) {
		CkString_appendStr($this->_cPtr,$str);
	}

	function appendEnc($s,$encoding) {
		CkString_appendEnc($this->_cPtr,$s,$encoding);
	}

	function getEnc($encoding) {
		return CkString_getEnc($this->_cPtr,$encoding);
	}

	function setString($s) {
		CkString_setString($this->_cPtr,$s);
	}

	function setStringAnsi($s) {
		CkString_setStringAnsi($this->_cPtr,$s);
	}

	function setStringUtf8($s) {
		CkString_setStringUtf8($this->_cPtr,$s);
	}

	function getAnsi() {
		return CkString_getAnsi($this->_cPtr);
	}

	function getUtf8() {
		return CkString_getUtf8($this->_cPtr);
	}

	function compareStr($str) {
		return CkString_compareStr($this->_cPtr,$str);
	}

	function getString() {
		return CkString_getString($this->_cPtr);
	}

	function getSizeUtf8() {
		return CkString_getSizeUtf8($this->_cPtr);
	}

	function getSizeAnsi() {
		return CkString_getSizeAnsi($this->_cPtr);
	}

	function getNumChars() {
		return CkString_getNumChars($this->_cPtr);
	}

	function trim() {
		CkString_trim($this->_cPtr);
	}

	function trim2() {
		CkString_trim2($this->_cPtr);
	}

	function trimInsideSpaces() {
		CkString_trimInsideSpaces($this->_cPtr);
	}

	function replaceAllOccurances($pattern,$replacement) {
		return CkString_replaceAllOccurances($this->_cPtr,$pattern,$replacement);
	}

	function replaceFirstOccurance($pattern,$replacement) {
		return CkString_replaceFirstOccurance($this->_cPtr,$pattern,$replacement);
	}

	function toCRLF() {
		CkString_toCRLF($this->_cPtr);
	}

	function toLF() {
		CkString_toLF($this->_cPtr);
	}

	function eliminateChar($ansiChar,$startIndex) {
		CkString_eliminateChar($this->_cPtr,$ansiChar,$startIndex);
	}

	function lastChar() {
		return CkString_lastChar($this->_cPtr);
	}

	function shorten($n) {
		CkString_shorten($this->_cPtr,$n);
	}

	function toLowerCase() {
		CkString_toLowerCase($this->_cPtr);
	}

	function toUpperCase() {
		CkString_toUpperCase($this->_cPtr);
	}

	function encodeXMLSpecial() {
		CkString_encodeXMLSpecial($this->_cPtr);
	}

	function decodeXMLSpecial() {
		CkString_decodeXMLSpecial($this->_cPtr);
	}

	function containsSubstring($pattern) {
		return CkString_containsSubstring($this->_cPtr,$pattern);
	}

	function containsSubstringNoCase($pattern) {
		return CkString_containsSubstringNoCase($this->_cPtr,$pattern);
	}

	function equals($s) {
		return CkString_equals($this->_cPtr,$s);
	}

	function equalsStr($s) {
		return CkString_equalsStr($this->_cPtr,$s);
	}

	function equalsIgnoreCase($s) {
		return CkString_equalsIgnoreCase($this->_cPtr,$s);
	}

	function equalsIgnoreCaseStr($s) {
		return CkString_equalsIgnoreCaseStr($this->_cPtr,$s);
	}

	function removeChunk($charStartPos,$numChars) {
		CkString_removeChunk($this->_cPtr,$charStartPos,$numChars);
	}

	function removeCharOccurances($c_) {
		CkString_removeCharOccurances($this->_cPtr,$c_);
	}

	function replaceChar($c1,$c2) {
		CkString_replaceChar($this->_cPtr,$c1,$c2);
	}

	function chopAtFirstChar($c1) {
		CkString_chopAtFirstChar($this->_cPtr,$c1);
	}

	function saveToFile($filename,$charset) {
		return CkString_saveToFile($this->_cPtr,$filename,$charset);
	}

	function split($splitChar,$exceptDoubleQuoted,$exceptEscaped,$keepEmpty) {
		$r=CkString_split($this->_cPtr,$splitChar,$exceptDoubleQuoted,$exceptEscaped,$keepEmpty);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function split2($splitCharSet,$exceptDoubleQuoted,$exceptEscaped,$keepEmpty) {
		$r=CkString_split2($this->_cPtr,$splitCharSet,$exceptDoubleQuoted,$exceptEscaped,$keepEmpty);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function tokenize($punctuation) {
		$r=CkString_tokenize($this->_cPtr,$punctuation);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function splitAtWS() {
		$r=CkString_splitAtWS($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function beginsWith($sSubstr) {
		return CkString_beginsWith($this->_cPtr,$sSubstr);
	}
}

class CkDateTime {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkDateTime') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkDateTime();
	}

	function get_Utf8() {
		return CkDateTime_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkDateTime_put_Utf8($this->_cPtr,$b);
	}

	function get_IsDst() {
		return CkDateTime_get_IsDst($this->_cPtr);
	}

	function get_UtcOffset() {
		return CkDateTime_get_UtcOffset($this->_cPtr);
	}

	function SetFromCurrentSystemTime() {
		CkDateTime_SetFromCurrentSystemTime($this->_cPtr);
	}

	function SetFromRfc822($rfc822Str) {
		return CkDateTime_SetFromRfc822($this->_cPtr,$rfc822Str);
	}

	function GetAsUnixTimeInt($bLocal) {
		return CkDateTime_GetAsUnixTimeInt($this->_cPtr,$bLocal);
	}

	function GetAsOleDate($bLocal) {
		return CkDateTime_GetAsOleDate($this->_cPtr,$bLocal);
	}

	function GetAsDosDate($bLocal) {
		return CkDateTime_GetAsDosDate($this->_cPtr,$bLocal);
	}

	function SetFromOleDate($bLocal,$dt) {
		CkDateTime_SetFromOleDate($this->_cPtr,$bLocal,$dt);
	}

	function SetFromDosDate($bLocal,$t) {
		CkDateTime_SetFromDosDate($this->_cPtr,$bLocal,$t);
	}

	function serialize() {
		return CkDateTime_serialize($this->_cPtr);
	}

	function DeSerialize($serializedDateTime) {
		CkDateTime_DeSerialize($this->_cPtr,$serializedDateTime);
	}

	function AddDays($numDays) {
		return CkDateTime_AddDays($this->_cPtr,$numDays);
	}

	function getAsRfc822($bLocal) {
		return CkDateTime_getAsRfc822($this->_cPtr,$bLocal);
	}

	function get_LastMethodSuccess() {
		return CkDateTime_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkDateTime_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function AddSeconds($numSeconds) {
		return CkDateTime_AddSeconds($this->_cPtr,$numSeconds);
	}

	function DiffSeconds($dt) {
		return CkDateTime_DiffSeconds($this->_cPtr,$dt);
	}

	function getAsUnixTimeStr($bLocal) {
		return CkDateTime_getAsUnixTimeStr($this->_cPtr,$bLocal);
	}

	function getAsIso8601($formatStr,$bLocal) {
		return CkDateTime_getAsIso8601($this->_cPtr,$formatStr,$bLocal);
	}

	function getAsTimestamp($bLocal) {
		return CkDateTime_getAsTimestamp($this->_cPtr,$bLocal);
	}

	function ExpiresWithin($n,$units) {
		return CkDateTime_ExpiresWithin($this->_cPtr,$n,$units);
	}

	function OlderThan($n,$units) {
		return CkDateTime_OlderThan($this->_cPtr,$n,$units);
	}

	function GetDtObj($bLocal) {
		$r=CkDateTime_GetDtObj($this->_cPtr,$bLocal);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDtObj($r);
		}
		return $r;
	}

	function SetFromDtObj($dtObj) {
		return CkDateTime_SetFromDtObj($this->_cPtr,$dtObj);
	}

	function LoadTaskResult($task) {
		return CkDateTime_LoadTaskResult($this->_cPtr,$task);
	}

	function SetFromNtpTime($t) {
		return CkDateTime_SetFromNtpTime($this->_cPtr,$t);
	}

	function SetFromTimestamp($rfc3339Str) {
		return CkDateTime_SetFromTimestamp($this->_cPtr,$rfc3339Str);
	}

	function SetFromNtpServer($jsonNtpInfo) {
		return CkDateTime_SetFromNtpServer($this->_cPtr,$jsonNtpInfo);
	}
}

class CkDtObj {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkDtObj') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkDtObj();
	}

	function get_Utf8() {
		return CkDtObj_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkDtObj_put_Utf8($this->_cPtr,$b);
	}

	function get_Utc() {
		return CkDtObj_get_Utc($this->_cPtr);
	}

	function put_Utc($newVal) {
		CkDtObj_put_Utc($this->_cPtr,$newVal);
	}

	function get_Year() {
		return CkDtObj_get_Year($this->_cPtr);
	}

	function put_Year($newVal) {
		CkDtObj_put_Year($this->_cPtr,$newVal);
	}

	function get_Month() {
		return CkDtObj_get_Month($this->_cPtr);
	}

	function put_Month($newVal) {
		CkDtObj_put_Month($this->_cPtr,$newVal);
	}

	function get_Day() {
		return CkDtObj_get_Day($this->_cPtr);
	}

	function put_Day($newVal) {
		CkDtObj_put_Day($this->_cPtr,$newVal);
	}

	function get_Hour() {
		return CkDtObj_get_Hour($this->_cPtr);
	}

	function put_Hour($newVal) {
		CkDtObj_put_Hour($this->_cPtr,$newVal);
	}

	function get_Minute() {
		return CkDtObj_get_Minute($this->_cPtr);
	}

	function put_Minute($newVal) {
		CkDtObj_put_Minute($this->_cPtr,$newVal);
	}

	function get_Second() {
		return CkDtObj_get_Second($this->_cPtr);
	}

	function put_Second($newVal) {
		CkDtObj_put_Second($this->_cPtr,$newVal);
	}

	function get_StructTmYear() {
		return CkDtObj_get_StructTmYear($this->_cPtr);
	}

	function put_StructTmYear($newVal) {
		CkDtObj_put_StructTmYear($this->_cPtr,$newVal);
	}

	function get_StructTmMonth() {
		return CkDtObj_get_StructTmMonth($this->_cPtr);
	}

	function put_StructTmMonth($newVal) {
		CkDtObj_put_StructTmMonth($this->_cPtr,$newVal);
	}

	function serialize() {
		return CkDtObj_serialize($this->_cPtr);
	}

	function DeSerialize($serializedDtObj) {
		CkDtObj_DeSerialize($this->_cPtr,$serializedDtObj);
	}
}

class CkByteData {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkByteData') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkByteData();
	}

	function get_Utf8() {
		return CkByteData_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkByteData_put_Utf8($this->_cPtr,$b);
	}

	function to_s() {
		return CkByteData_to_s($this->_cPtr);
	}

	function appendRandom($numBytes) {
		CkByteData_appendRandom($this->_cPtr,$numBytes);
	}

	function appendInt($v,$littleEndian) {
		CkByteData_appendInt($this->_cPtr,$v,$littleEndian);
	}

	function appendShort($v,$littleEndian) {
		CkByteData_appendShort($this->_cPtr,$v,$littleEndian);
	}

	function getEncodedRange($encoding,$index,$numBytes) {
		return CkByteData_getEncodedRange($this->_cPtr,$encoding,$index,$numBytes);
	}

	function appendRange($byteData,$index,$numBytes) {
		CkByteData_appendRange($this->_cPtr,$byteData,$index,$numBytes);
	}

	function ensureBuffer($numBytes) {
		CkByteData_ensureBuffer($this->_cPtr,$numBytes);
	}

	function findBytes2($byteData,$byteDataLen) {
		return CkByteData_findBytes2($this->_cPtr,$byteData,$byteDataLen);
	}

	function findBytes($byteData) {
		return CkByteData_findBytes($this->_cPtr,$byteData);
	}

	function beginsWith2($byteData,$byteDataLen) {
		return CkByteData_beginsWith2($this->_cPtr,$byteData,$byteDataLen);
	}

	function beginsWith($byteData) {
		return CkByteData_beginsWith($this->_cPtr,$byteData);
	}

	function removeChunk($index,$numBytes) {
		CkByteData_removeChunk($this->_cPtr,$index,$numBytes);
	}

	function byteSwap4321() {
		CkByteData_byteSwap4321($this->_cPtr);
	}

	function pad($blockSize,$paddingScheme) {
		CkByteData_pad($this->_cPtr,$blockSize,$paddingScheme);
	}

	function unpad($blockSize,$paddingScheme) {
		CkByteData_unpad($this->_cPtr,$blockSize,$paddingScheme);
	}

	function is7bit() {
		return CkByteData_is7bit($this->_cPtr);
	}

	function clear() {
		CkByteData_clear($this->_cPtr);
	}

	function getSize() {
		return CkByteData_getSize($this->_cPtr);
	}

	function appendEncoded($str,$encoding) {
		CkByteData_appendEncoded($this->_cPtr,$str,$encoding);
	}

	function encode($encoding,$str) {
		CkByteData_encode($this->_cPtr,$encoding,$str);
	}

	function getData() {
		return CkByteData_getData($this->_cPtr);
	}

	function getBytes() {
		return CkByteData_getBytes($this->_cPtr);
	}

	function getEncoded($encoding) {
		return CkByteData_getEncoded($this->_cPtr,$encoding);
	}

	function getRange($index,$numBytes) {
		return CkByteData_getRange($this->_cPtr,$index,$numBytes);
	}

	function getRangeStr($index,$numAnsiChars) {
		return CkByteData_getRangeStr($this->_cPtr,$index,$numAnsiChars);
	}

	function append2($data,$numBytes) {
		CkByteData_append2($this->_cPtr,$data,$numBytes);
	}

	function equals2($data,$numBytes) {
		return CkByteData_equals2($this->_cPtr,$data,$numBytes);
	}

	function equals($db) {
		return CkByteData_equals($this->_cPtr,$db);
	}

	function appendStr($str) {
		CkByteData_appendStr($this->_cPtr,$str);
	}

	function appendChar($ch) {
		CkByteData_appendChar($this->_cPtr,$ch);
	}

	function getByte($byteIndex) {
		return CkByteData_getByte($this->_cPtr,$byteIndex);
	}

	function getChar($byteIndex) {
		return CkByteData_getChar($this->_cPtr,$byteIndex);
	}

	function getUInt($byteIndex) {
		return CkByteData_getUInt($this->_cPtr,$byteIndex);
	}

	function getInt($byteIndex) {
		return CkByteData_getInt($this->_cPtr,$byteIndex);
	}

	function getUShort($byteIndex) {
		return CkByteData_getUShort($this->_cPtr,$byteIndex);
	}

	function getShort($byteIndex) {
		return CkByteData_getShort($this->_cPtr,$byteIndex);
	}

	function loadFile($filename) {
		return CkByteData_loadFile($this->_cPtr,$filename);
	}

	function saveFile($filename) {
		return CkByteData_saveFile($this->_cPtr,$filename);
	}

	function appendFile($filename) {
		return CkByteData_appendFile($this->_cPtr,$filename);
	}

	function shorten($numBytes) {
		CkByteData_shorten($this->_cPtr,$numBytes);
	}
}

class CkAi {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkAi') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkAi();
	}

	function get_Utf8() {
		return CkAi_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkAi_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkAi_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_ApiKey($str) {
		CkAi_get_ApiKey($this->_cPtr,$str);
	}

	function apiKey() {
		return CkAi_apiKey($this->_cPtr);
	}

	function put_ApiKey($newVal) {
		CkAi_put_ApiKey($this->_cPtr,$newVal);
	}

	function get_ApiKeyHeader($str) {
		CkAi_get_ApiKeyHeader($this->_cPtr,$str);
	}

	function apiKeyHeader() {
		return CkAi_apiKeyHeader($this->_cPtr);
	}

	function put_ApiKeyHeader($newVal) {
		CkAi_put_ApiKeyHeader($this->_cPtr,$newVal);
	}

	function get_ApiSpec($str) {
		CkAi_get_ApiSpec($this->_cPtr,$str);
	}

	function apiSpec() {
		return CkAi_apiSpec($this->_cPtr);
	}

	function put_ApiSpec($newVal) {
		CkAi_put_ApiSpec($this->_cPtr,$newVal);
	}

	function get_BaseUrl($str) {
		CkAi_get_BaseUrl($this->_cPtr,$str);
	}

	function baseUrl() {
		return CkAi_baseUrl($this->_cPtr);
	}

	function put_BaseUrl($newVal) {
		CkAi_put_BaseUrl($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkAi_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkAi_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkAi_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_FullTranscript() {
		return CkAi_get_FullTranscript($this->_cPtr);
	}

	function put_FullTranscript($newVal) {
		CkAi_put_FullTranscript($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkAi_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkAi_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_HostedConvo() {
		return CkAi_get_HostedConvo($this->_cPtr);
	}

	function put_HostedConvo($newVal) {
		CkAi_put_HostedConvo($this->_cPtr,$newVal);
	}

	function get_IdleTimeoutMs() {
		return CkAi_get_IdleTimeoutMs($this->_cPtr);
	}

	function put_IdleTimeoutMs($newVal) {
		CkAi_put_IdleTimeoutMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkAi_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkAi_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkAi_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkAi_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkAi_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkAi_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkAi_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkAi_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Model($str) {
		CkAi_get_Model($this->_cPtr,$str);
	}

	function model() {
		return CkAi_model($this->_cPtr);
	}

	function put_Model($newVal) {
		CkAi_put_Model($this->_cPtr,$newVal);
	}

	function get_Provider($str) {
		CkAi_get_Provider($this->_cPtr,$str);
	}

	function provider() {
		return CkAi_provider($this->_cPtr);
	}

	function put_Provider($newVal) {
		CkAi_put_Provider($this->_cPtr,$newVal);
	}

	function get_ResponseStatusCode() {
		return CkAi_get_ResponseStatusCode($this->_cPtr);
	}

	function get_SelectedConvo($str) {
		CkAi_get_SelectedConvo($this->_cPtr,$str);
	}

	function selectedConvo() {
		return CkAi_selectedConvo($this->_cPtr);
	}

	function put_SelectedConvo($newVal) {
		CkAi_put_SelectedConvo($this->_cPtr,$newVal);
	}

	function get_Streaming() {
		return CkAi_get_Streaming($this->_cPtr);
	}

	function put_Streaming($newVal) {
		CkAi_put_Streaming($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkAi_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkAi_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkAi_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkAi_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkAi_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkAi_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkAi_version($this->_cPtr);
	}

	function Ask($outputType) {
		return CkAi_Ask($this->_cPtr,$outputType);
	}

	function AskAsync($outputType) {
		$r=CkAi_AskAsync($this->_cPtr,$outputType);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteConvo($name) {
		return CkAi_DeleteConvo($this->_cPtr,$name);
	}

	function ExportConvo($name,$json) {
		return CkAi_ExportConvo($this->_cPtr,$name,$json);
	}

	function GetLastJsonData($json) {
		CkAi_GetLastJsonData($this->_cPtr,$json);
	}

	function GetModels($st) {
		return CkAi_GetModels($this->_cPtr,$st);
	}

	function GetModelsAsync($st) {
		$r=CkAi_GetModelsAsync($this->_cPtr,$st);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getOutputText() {
		return CkAi_getOutputText($this->_cPtr);
	}

	function outputText() {
		return CkAi_outputText($this->_cPtr);
	}

	function GetOutputTextSb($sb) {
		return CkAi_GetOutputTextSb($this->_cPtr,$sb);
	}

	function ImportConvo($name,$json) {
		return CkAi_ImportConvo($this->_cPtr,$name,$json);
	}

	function InputAddFileData($filename,$bd,$summary) {
		return CkAi_InputAddFileData($this->_cPtr,$filename,$bd,$summary);
	}

	function InputAddFileUrl($url,$summary) {
		return CkAi_InputAddFileUrl($this->_cPtr,$url,$summary);
	}

	function InputAddImageData($bd,$summary) {
		return CkAi_InputAddImageData($this->_cPtr,$bd,$summary);
	}

	function InputAddImageUrl($url,$summary) {
		return CkAi_InputAddImageUrl($this->_cPtr,$url,$summary);
	}

	function InputAddText($text) {
		return CkAi_InputAddText($this->_cPtr,$text);
	}

	function InputAddTextSb($sb) {
		return CkAi_InputAddTextSb($this->_cPtr,$sb);
	}

	function InputClear() {
		CkAi_InputClear($this->_cPtr);
	}

	function ListConvos($st) {
		return CkAi_ListConvos($this->_cPtr,$st);
	}

	function NewConvo($name,$sysMsg,$devMsg) {
		return CkAi_NewConvo($this->_cPtr,$name,$sysMsg,$devMsg);
	}

	function NextAiEvent($maxWaitMs,$sbName,$sbDelta) {
		return CkAi_NextAiEvent($this->_cPtr,$maxWaitMs,$sbName,$sbDelta);
	}

	function PollAi($abort) {
		return CkAi_PollAi($this->_cPtr,$abort);
	}

	function SetAskParams($json) {
		return CkAi_SetAskParams($this->_cPtr,$json);
	}

	function SetConnectionSettings($sock) {
		return CkAi_SetConnectionSettings($this->_cPtr,$sock);
	}

	function SetProviderParams($json) {
		return CkAi_SetProviderParams($this->_cPtr,$json);
	}

	function SleepMs($millisec) {
		CkAi_SleepMs($this->_cPtr,$millisec);
	}
}

class CkAsn {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkAsn') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkAsn();
	}

	function get_Utf8() {
		return CkAsn_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkAsn_put_Utf8($this->_cPtr,$b);
	}

	function get_BoolValue() {
		return CkAsn_get_BoolValue($this->_cPtr);
	}

	function put_BoolValue($newVal) {
		CkAsn_put_BoolValue($this->_cPtr,$newVal);
	}

	function get_Constructed() {
		return CkAsn_get_Constructed($this->_cPtr);
	}

	function get_ContentStr($str) {
		CkAsn_get_ContentStr($this->_cPtr,$str);
	}

	function contentStr() {
		return CkAsn_contentStr($this->_cPtr);
	}

	function put_ContentStr($newVal) {
		CkAsn_put_ContentStr($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkAsn_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkAsn_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkAsn_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_IntValue() {
		return CkAsn_get_IntValue($this->_cPtr);
	}

	function put_IntValue($newVal) {
		CkAsn_put_IntValue($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkAsn_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkAsn_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkAsn_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkAsn_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkAsn_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkAsn_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkAsn_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkAsn_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumSubItems() {
		return CkAsn_get_NumSubItems($this->_cPtr);
	}

	function get_Tag($str) {
		CkAsn_get_Tag($this->_cPtr,$str);
	}

	function tag() {
		return CkAsn_tag($this->_cPtr);
	}

	function get_TagValue() {
		return CkAsn_get_TagValue($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkAsn_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkAsn_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkAsn_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkAsn_version($this->_cPtr);
	}

	function AppendBigInt($encodedBytes,$encoding) {
		return CkAsn_AppendBigInt($this->_cPtr,$encodedBytes,$encoding);
	}

	function AppendBits($encodedBytes,$encoding) {
		return CkAsn_AppendBits($this->_cPtr,$encodedBytes,$encoding);
	}

	function AppendBool($value) {
		return CkAsn_AppendBool($this->_cPtr,$value);
	}

	function AppendContextConstructed($tag) {
		return CkAsn_AppendContextConstructed($this->_cPtr,$tag);
	}

	function AppendContextPrimitive($tag,$encodedBytes,$encoding) {
		return CkAsn_AppendContextPrimitive($this->_cPtr,$tag,$encodedBytes,$encoding);
	}

	function AppendInt($value) {
		return CkAsn_AppendInt($this->_cPtr,$value);
	}

	function AppendNull() {
		return CkAsn_AppendNull($this->_cPtr);
	}

	function AppendOctets($encodedBytes,$encoding) {
		return CkAsn_AppendOctets($this->_cPtr,$encodedBytes,$encoding);
	}

	function AppendOid($oid) {
		return CkAsn_AppendOid($this->_cPtr,$oid);
	}

	function AppendSequence() {
		return CkAsn_AppendSequence($this->_cPtr);
	}

	function AppendSequence2() {
		return CkAsn_AppendSequence2($this->_cPtr);
	}

	function AppendSequenceR() {
		$r=CkAsn_AppendSequenceR($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkAsn($r);
		}
		return $r;
	}

	function AppendSet() {
		return CkAsn_AppendSet($this->_cPtr);
	}

	function AppendSet2() {
		return CkAsn_AppendSet2($this->_cPtr);
	}

	function AppendSetR() {
		$r=CkAsn_AppendSetR($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkAsn($r);
		}
		return $r;
	}

	function AppendString($strType,$value) {
		return CkAsn_AppendString($this->_cPtr,$strType,$value);
	}

	function AppendTime($timeFormat,$dateTimeStr) {
		return CkAsn_AppendTime($this->_cPtr,$timeFormat,$dateTimeStr);
	}

	function asnToXml() {
		return CkAsn_asnToXml($this->_cPtr);
	}

	function DeleteSubItem($index) {
		return CkAsn_DeleteSubItem($this->_cPtr,$index);
	}

	function GetBinaryDer($outBytes) {
		return CkAsn_GetBinaryDer($this->_cPtr,$outBytes);
	}

	function getEncodedContent($encoding) {
		return CkAsn_getEncodedContent($this->_cPtr,$encoding);
	}

	function encodedContent($encoding) {
		return CkAsn_encodedContent($this->_cPtr,$encoding);
	}

	function getEncodedDer($encoding) {
		return CkAsn_getEncodedDer($this->_cPtr,$encoding);
	}

	function encodedDer($encoding) {
		return CkAsn_encodedDer($this->_cPtr,$encoding);
	}

	function GetLastSubItem() {
		$r=CkAsn_GetLastSubItem($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkAsn($r);
		}
		return $r;
	}

	function GetSubItem($index) {
		$r=CkAsn_GetSubItem($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkAsn($r);
		}
		return $r;
	}

	function LoadAsnXml($xmlStr) {
		return CkAsn_LoadAsnXml($this->_cPtr,$xmlStr);
	}

	function LoadBd($bd) {
		return CkAsn_LoadBd($this->_cPtr,$bd);
	}

	function LoadBinary($derBytes) {
		return CkAsn_LoadBinary($this->_cPtr,$derBytes);
	}

	function LoadBinaryFile($path) {
		return CkAsn_LoadBinaryFile($this->_cPtr,$path);
	}

	function LoadEncoded($asnContent,$encoding) {
		return CkAsn_LoadEncoded($this->_cPtr,$asnContent,$encoding);
	}

	function SetEncodedContent($encodedBytes,$encoding) {
		return CkAsn_SetEncodedContent($this->_cPtr,$encodedBytes,$encoding);
	}

	function WriteBd($bd) {
		return CkAsn_WriteBd($this->_cPtr,$bd);
	}

	function WriteBinaryDer($path) {
		return CkAsn_WriteBinaryDer($this->_cPtr,$path);
	}
}

class CkAuthAws {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkAuthAws') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkAuthAws();
	}

	function get_Utf8() {
		return CkAuthAws_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkAuthAws_put_Utf8($this->_cPtr,$b);
	}

	function get_AccessKey($str) {
		CkAuthAws_get_AccessKey($this->_cPtr,$str);
	}

	function accessKey() {
		return CkAuthAws_accessKey($this->_cPtr);
	}

	function put_AccessKey($newVal) {
		CkAuthAws_put_AccessKey($this->_cPtr,$newVal);
	}

	function get_CanonicalizedResourceV2($str) {
		CkAuthAws_get_CanonicalizedResourceV2($this->_cPtr,$str);
	}

	function canonicalizedResourceV2() {
		return CkAuthAws_canonicalizedResourceV2($this->_cPtr);
	}

	function put_CanonicalizedResourceV2($newVal) {
		CkAuthAws_put_CanonicalizedResourceV2($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkAuthAws_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkAuthAws_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkAuthAws_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkAuthAws_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkAuthAws_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkAuthAws_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkAuthAws_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkAuthAws_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkAuthAws_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkAuthAws_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkAuthAws_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_PrecomputedMd5($str) {
		CkAuthAws_get_PrecomputedMd5($this->_cPtr,$str);
	}

	function precomputedMd5() {
		return CkAuthAws_precomputedMd5($this->_cPtr);
	}

	function put_PrecomputedMd5($newVal) {
		CkAuthAws_put_PrecomputedMd5($this->_cPtr,$newVal);
	}

	function get_PrecomputedSha256($str) {
		CkAuthAws_get_PrecomputedSha256($this->_cPtr,$str);
	}

	function precomputedSha256() {
		return CkAuthAws_precomputedSha256($this->_cPtr);
	}

	function put_PrecomputedSha256($newVal) {
		CkAuthAws_put_PrecomputedSha256($this->_cPtr,$newVal);
	}

	function get_Region($str) {
		CkAuthAws_get_Region($this->_cPtr,$str);
	}

	function region() {
		return CkAuthAws_region($this->_cPtr);
	}

	function put_Region($newVal) {
		CkAuthAws_put_Region($this->_cPtr,$newVal);
	}

	function get_SecretKey($str) {
		CkAuthAws_get_SecretKey($this->_cPtr,$str);
	}

	function secretKey() {
		return CkAuthAws_secretKey($this->_cPtr);
	}

	function put_SecretKey($newVal) {
		CkAuthAws_put_SecretKey($this->_cPtr,$newVal);
	}

	function get_ServiceName($str) {
		CkAuthAws_get_ServiceName($this->_cPtr,$str);
	}

	function serviceName() {
		return CkAuthAws_serviceName($this->_cPtr);
	}

	function put_ServiceName($newVal) {
		CkAuthAws_put_ServiceName($this->_cPtr,$newVal);
	}

	function get_SignatureVersion() {
		return CkAuthAws_get_SignatureVersion($this->_cPtr);
	}

	function put_SignatureVersion($newVal) {
		CkAuthAws_put_SignatureVersion($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkAuthAws_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkAuthAws_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkAuthAws_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkAuthAws_version($this->_cPtr);
	}

	function genPresignedUrl($httpVerb,$useHttps,$domain,$path,$numSecondsValid,$awsService) {
		return CkAuthAws_genPresignedUrl($this->_cPtr,$httpVerb,$useHttps,$domain,$path,$numSecondsValid,$awsService);
	}
}

class CkAuthAzureSAS {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkAuthAzureSAS') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkAuthAzureSAS();
	}

	function get_Utf8() {
		return CkAuthAzureSAS_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkAuthAzureSAS_put_Utf8($this->_cPtr,$b);
	}

	function get_AccessKey($str) {
		CkAuthAzureSAS_get_AccessKey($this->_cPtr,$str);
	}

	function accessKey() {
		return CkAuthAzureSAS_accessKey($this->_cPtr);
	}

	function put_AccessKey($newVal) {
		CkAuthAzureSAS_put_AccessKey($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkAuthAzureSAS_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkAuthAzureSAS_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkAuthAzureSAS_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkAuthAzureSAS_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkAuthAzureSAS_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkAuthAzureSAS_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkAuthAzureSAS_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkAuthAzureSAS_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkAuthAzureSAS_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkAuthAzureSAS_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkAuthAzureSAS_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_StringToSign($str) {
		CkAuthAzureSAS_get_StringToSign($this->_cPtr,$str);
	}

	function stringToSign() {
		return CkAuthAzureSAS_stringToSign($this->_cPtr);
	}

	function put_StringToSign($newVal) {
		CkAuthAzureSAS_put_StringToSign($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkAuthAzureSAS_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkAuthAzureSAS_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkAuthAzureSAS_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkAuthAzureSAS_version($this->_cPtr);
	}

	function Clear() {
		CkAuthAzureSAS_Clear($this->_cPtr);
	}

	function generateToken() {
		return CkAuthAzureSAS_generateToken($this->_cPtr);
	}

	function SetNonTokenParam($name,$value) {
		return CkAuthAzureSAS_SetNonTokenParam($this->_cPtr,$name,$value);
	}

	function SetTokenParam($name,$authParamName,$value) {
		return CkAuthAzureSAS_SetTokenParam($this->_cPtr,$name,$authParamName,$value);
	}
}

class CkAuthAzureStorage {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkAuthAzureStorage') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkAuthAzureStorage();
	}

	function get_Utf8() {
		return CkAuthAzureStorage_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkAuthAzureStorage_put_Utf8($this->_cPtr,$b);
	}

	function get_AccessKey($str) {
		CkAuthAzureStorage_get_AccessKey($this->_cPtr,$str);
	}

	function accessKey() {
		return CkAuthAzureStorage_accessKey($this->_cPtr);
	}

	function put_AccessKey($newVal) {
		CkAuthAzureStorage_put_AccessKey($this->_cPtr,$newVal);
	}

	function get_Account($str) {
		CkAuthAzureStorage_get_Account($this->_cPtr,$str);
	}

	function account() {
		return CkAuthAzureStorage_account($this->_cPtr);
	}

	function put_Account($newVal) {
		CkAuthAzureStorage_put_Account($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkAuthAzureStorage_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkAuthAzureStorage_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkAuthAzureStorage_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkAuthAzureStorage_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkAuthAzureStorage_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkAuthAzureStorage_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkAuthAzureStorage_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkAuthAzureStorage_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkAuthAzureStorage_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkAuthAzureStorage_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkAuthAzureStorage_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Scheme($str) {
		CkAuthAzureStorage_get_Scheme($this->_cPtr,$str);
	}

	function scheme() {
		return CkAuthAzureStorage_scheme($this->_cPtr);
	}

	function put_Scheme($newVal) {
		CkAuthAzureStorage_put_Scheme($this->_cPtr,$newVal);
	}

	function get_Service($str) {
		CkAuthAzureStorage_get_Service($this->_cPtr,$str);
	}

	function service() {
		return CkAuthAzureStorage_service($this->_cPtr);
	}

	function put_Service($newVal) {
		CkAuthAzureStorage_put_Service($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkAuthAzureStorage_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkAuthAzureStorage_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkAuthAzureStorage_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkAuthAzureStorage_version($this->_cPtr);
	}

	function get_XMsVersion($str) {
		CkAuthAzureStorage_get_XMsVersion($this->_cPtr,$str);
	}

	function xMsVersion() {
		return CkAuthAzureStorage_xMsVersion($this->_cPtr);
	}

	function put_XMsVersion($newVal) {
		CkAuthAzureStorage_put_XMsVersion($this->_cPtr,$newVal);
	}

	function Noop() {
		CkAuthAzureStorage_Noop($this->_cPtr);
	}
}

class CkAuthGoogle {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkAuthGoogle') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkAuthGoogle();
	}

	function get_Utf8() {
		return CkAuthGoogle_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkAuthGoogle_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkAuthGoogle_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AccessToken($str) {
		CkAuthGoogle_get_AccessToken($this->_cPtr,$str);
	}

	function accessToken() {
		return CkAuthGoogle_accessToken($this->_cPtr);
	}

	function put_AccessToken($newVal) {
		CkAuthGoogle_put_AccessToken($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkAuthGoogle_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkAuthGoogle_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkAuthGoogle_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EmailAddress($str) {
		CkAuthGoogle_get_EmailAddress($this->_cPtr,$str);
	}

	function emailAddress() {
		return CkAuthGoogle_emailAddress($this->_cPtr);
	}

	function put_EmailAddress($newVal) {
		CkAuthGoogle_put_EmailAddress($this->_cPtr,$newVal);
	}

	function get_ExpireNumSeconds() {
		return CkAuthGoogle_get_ExpireNumSeconds($this->_cPtr);
	}

	function put_ExpireNumSeconds($newVal) {
		CkAuthGoogle_put_ExpireNumSeconds($this->_cPtr,$newVal);
	}

	function get_Iat() {
		return CkAuthGoogle_get_Iat($this->_cPtr);
	}

	function put_Iat($newVal) {
		CkAuthGoogle_put_Iat($this->_cPtr,$newVal);
	}

	function get_JsonKey($str) {
		CkAuthGoogle_get_JsonKey($this->_cPtr,$str);
	}

	function jsonKey() {
		return CkAuthGoogle_jsonKey($this->_cPtr);
	}

	function put_JsonKey($newVal) {
		CkAuthGoogle_put_JsonKey($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkAuthGoogle_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkAuthGoogle_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkAuthGoogle_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkAuthGoogle_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkAuthGoogle_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkAuthGoogle_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkAuthGoogle_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkAuthGoogle_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumSecondsRemaining() {
		return CkAuthGoogle_get_NumSecondsRemaining($this->_cPtr);
	}

	function get_Scope($str) {
		CkAuthGoogle_get_Scope($this->_cPtr,$str);
	}

	function scope() {
		return CkAuthGoogle_scope($this->_cPtr);
	}

	function put_Scope($newVal) {
		CkAuthGoogle_put_Scope($this->_cPtr,$newVal);
	}

	function get_SubEmailAddress($str) {
		CkAuthGoogle_get_SubEmailAddress($this->_cPtr,$str);
	}

	function subEmailAddress() {
		return CkAuthGoogle_subEmailAddress($this->_cPtr);
	}

	function put_SubEmailAddress($newVal) {
		CkAuthGoogle_put_SubEmailAddress($this->_cPtr,$newVal);
	}

	function get_Valid() {
		return CkAuthGoogle_get_Valid($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkAuthGoogle_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkAuthGoogle_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkAuthGoogle_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkAuthGoogle_version($this->_cPtr);
	}

	function AddClaims($json) {
		return CkAuthGoogle_AddClaims($this->_cPtr,$json);
	}

	function GetP12() {
		$r=CkAuthGoogle_GetP12($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPfx($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkAuthGoogle_LoadTaskCaller($this->_cPtr,$task);
	}

	function ObtainAccessToken($connection) {
		return CkAuthGoogle_ObtainAccessToken($this->_cPtr,$connection);
	}

	function ObtainAccessTokenAsync($connection) {
		$r=CkAuthGoogle_ObtainAccessTokenAsync($this->_cPtr,$connection);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetP12($key) {
		return CkAuthGoogle_SetP12($this->_cPtr,$key);
	}
}

class CkBinData {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkBinData') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkBinData();
	}

	function get_Utf8() {
		return CkBinData_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkBinData_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkBinData_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkBinData_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkBinData_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkBinData_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkBinData_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkBinData_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkBinData_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkBinData_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkBinData_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkBinData_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkBinData_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumBytes() {
		return CkBinData_get_NumBytes($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkBinData_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkBinData_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkBinData_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkBinData_version($this->_cPtr);
	}

	function AppendBd($binData) {
		return CkBinData_AppendBd($this->_cPtr,$binData);
	}

	function AppendBinary($data) {
		return CkBinData_AppendBinary($this->_cPtr,$data);
	}

	function AppendBom($charset) {
		return CkBinData_AppendBom($this->_cPtr,$charset);
	}

	function AppendByte($byteValue) {
		return CkBinData_AppendByte($this->_cPtr,$byteValue);
	}

	function AppendCountedString($numCountBytes,$bigEndian,$str,$charset) {
		return CkBinData_AppendCountedString($this->_cPtr,$numCountBytes,$bigEndian,$str,$charset);
	}

	function AppendData($data,$numBytes) {
		return CkBinData_AppendData($this->_cPtr,$data,$numBytes);
	}

	function AppendEncoded($encData,$encoding) {
		return CkBinData_AppendEncoded($this->_cPtr,$encData,$encoding);
	}

	function AppendEncodedSb($sb,$encoding) {
		return CkBinData_AppendEncodedSb($this->_cPtr,$sb,$encoding);
	}

	function AppendInt2($value,$littleEndian) {
		return CkBinData_AppendInt2($this->_cPtr,$value,$littleEndian);
	}

	function AppendInt4($value,$littleEndian) {
		return CkBinData_AppendInt4($this->_cPtr,$value,$littleEndian);
	}

	function AppendPadded($str,$charset,$padWithSpace,$fieldLen) {
		return CkBinData_AppendPadded($this->_cPtr,$str,$charset,$padWithSpace,$fieldLen);
	}

	function AppendSb($sb,$charset) {
		return CkBinData_AppendSb($this->_cPtr,$sb,$charset);
	}

	function AppendString($str,$charset) {
		return CkBinData_AppendString($this->_cPtr,$str,$charset);
	}

	function ByteSwap($size) {
		CkBinData_ByteSwap($this->_cPtr,$size);
	}

	function CharsetConvert($fromCharset,$toCharset,$allOrNone) {
		return CkBinData_CharsetConvert($this->_cPtr,$fromCharset,$toCharset,$allOrNone);
	}

	function Clear() {
		return CkBinData_Clear($this->_cPtr);
	}

	function ContentsEqual($binData) {
		return CkBinData_ContentsEqual($this->_cPtr,$binData);
	}

	function FindString($str,$startIdx,$charset) {
		return CkBinData_FindString($this->_cPtr,$str,$startIdx,$charset);
	}

	function GetBinary($outBytes) {
		return CkBinData_GetBinary($this->_cPtr,$outBytes);
	}

	function GetBinaryChunk($offset,$numBytes,$outBytes) {
		return CkBinData_GetBinaryChunk($this->_cPtr,$offset,$numBytes,$outBytes);
	}

	function GetByte($index) {
		return CkBinData_GetByte($this->_cPtr,$index);
	}

	function GetData() {
		return CkBinData_GetData($this->_cPtr);
	}

	function GetDataChunk($offset,$numBytes) {
		return CkBinData_GetDataChunk($this->_cPtr,$offset,$numBytes);
	}

	function getEncoded($encoding) {
		return CkBinData_getEncoded($this->_cPtr,$encoding);
	}

	function encoded($encoding) {
		return CkBinData_encoded($this->_cPtr,$encoding);
	}

	function getEncodedChunk($offset,$numBytes,$encoding) {
		return CkBinData_getEncodedChunk($this->_cPtr,$offset,$numBytes,$encoding);
	}

	function encodedChunk($offset,$numBytes,$encoding) {
		return CkBinData_encodedChunk($this->_cPtr,$offset,$numBytes,$encoding);
	}

	function GetEncodedSb($encoding,$sb) {
		return CkBinData_GetEncodedSb($this->_cPtr,$encoding,$sb);
	}

	function getHash($algorithm,$encoding) {
		return CkBinData_getHash($this->_cPtr,$algorithm,$encoding);
	}

	function hash($algorithm,$encoding) {
		return CkBinData_hash($this->_cPtr,$algorithm,$encoding);
	}

	function GetInt2($index,$littleEndian) {
		return CkBinData_GetInt2($this->_cPtr,$index,$littleEndian);
	}

	function GetInt4($index,$littleEndian) {
		return CkBinData_GetInt4($this->_cPtr,$index,$littleEndian);
	}

	function getString($charset) {
		return CkBinData_getString($this->_cPtr,$charset);
	}

	function string($charset) {
		return CkBinData_string($this->_cPtr,$charset);
	}

	function getTextChunk($startIdx,$numBytes,$charset) {
		return CkBinData_getTextChunk($this->_cPtr,$startIdx,$numBytes,$charset);
	}

	function textChunk($startIdx,$numBytes,$charset) {
		return CkBinData_textChunk($this->_cPtr,$startIdx,$numBytes,$charset);
	}

	function GetUInt2($index,$littleEndian) {
		return CkBinData_GetUInt2($this->_cPtr,$index,$littleEndian);
	}

	function GetUInt4($index,$littleEndian) {
		return CkBinData_GetUInt4($this->_cPtr,$index,$littleEndian);
	}

	function IsValidUtf8() {
		return CkBinData_IsValidUtf8($this->_cPtr);
	}

	function LoadBinary($data) {
		return CkBinData_LoadBinary($this->_cPtr,$data);
	}

	function LoadEncoded($encData,$encoding) {
		return CkBinData_LoadEncoded($this->_cPtr,$encData,$encoding);
	}

	function LoadFile($path) {
		return CkBinData_LoadFile($this->_cPtr,$path);
	}

	function RemoveByteVal($value) {
		CkBinData_RemoveByteVal($this->_cPtr,$value);
	}

	function RemoveChunk($offset,$numBytes) {
		return CkBinData_RemoveChunk($this->_cPtr,$offset,$numBytes);
	}

	function SecureClear() {
		return CkBinData_SecureClear($this->_cPtr);
	}

	function WriteAppendFile($path) {
		return CkBinData_WriteAppendFile($this->_cPtr,$path);
	}

	function WriteFile($path) {
		return CkBinData_WriteFile($this->_cPtr,$path);
	}
}

class CkBz2 {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkBz2') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkBz2();
	}

	function get_Utf8() {
		return CkBz2_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkBz2_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkBz2_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkBz2_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkBz2_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkBz2_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkBz2_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkBz2_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkBz2_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkBz2_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkBz2_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkBz2_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkBz2_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkBz2_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkBz2_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkBz2_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkBz2_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkBz2_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkBz2_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkBz2_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkBz2_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkBz2_version($this->_cPtr);
	}

	function CompressBd($bd) {
		return CkBz2_CompressBd($this->_cPtr,$bd);
	}

	function CompressBdAsync($bd) {
		$r=CkBz2_CompressBdAsync($this->_cPtr,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressFile($inFilename,$toPath) {
		return CkBz2_CompressFile($this->_cPtr,$inFilename,$toPath);
	}

	function CompressFileAsync($inFilename,$toPath) {
		$r=CkBz2_CompressFileAsync($this->_cPtr,$inFilename,$toPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressFileToMem($inFilename,$outBytes) {
		return CkBz2_CompressFileToMem($this->_cPtr,$inFilename,$outBytes);
	}

	function CompressFileToMemAsync($inFilename) {
		$r=CkBz2_CompressFileToMemAsync($this->_cPtr,$inFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressMemory($inData,$outBytes) {
		return CkBz2_CompressMemory($this->_cPtr,$inData,$outBytes);
	}

	function CompressMemoryAsync($inData) {
		$r=CkBz2_CompressMemoryAsync($this->_cPtr,$inData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressMemToFile($inData,$toPath) {
		return CkBz2_CompressMemToFile($this->_cPtr,$inData,$toPath);
	}

	function CompressMemToFileAsync($inData,$toPath) {
		$r=CkBz2_CompressMemToFileAsync($this->_cPtr,$inData,$toPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkBz2_LoadTaskCaller($this->_cPtr,$task);
	}

	function UncompressBd($bd) {
		return CkBz2_UncompressBd($this->_cPtr,$bd);
	}

	function UncompressBdAsync($bd) {
		$r=CkBz2_UncompressBdAsync($this->_cPtr,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressFile($inFilename,$toPath) {
		return CkBz2_UncompressFile($this->_cPtr,$inFilename,$toPath);
	}

	function UncompressFileAsync($inFilename,$toPath) {
		$r=CkBz2_UncompressFileAsync($this->_cPtr,$inFilename,$toPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressFileToMem($inFilename,$outBytes) {
		return CkBz2_UncompressFileToMem($this->_cPtr,$inFilename,$outBytes);
	}

	function UncompressFileToMemAsync($inFilename) {
		$r=CkBz2_UncompressFileToMemAsync($this->_cPtr,$inFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressMemory($inData,$outBytes) {
		return CkBz2_UncompressMemory($this->_cPtr,$inData,$outBytes);
	}

	function UncompressMemoryAsync($inData) {
		$r=CkBz2_UncompressMemoryAsync($this->_cPtr,$inData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressMemToFile($inData,$toPath) {
		return CkBz2_UncompressMemToFile($this->_cPtr,$inData,$toPath);
	}

	function UncompressMemToFileAsync($inData,$toPath) {
		$r=CkBz2_UncompressMemToFileAsync($this->_cPtr,$inData,$toPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkCache {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkCache') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkCache();
	}

	function get_Utf8() {
		return CkCache_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkCache_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkCache_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkCache_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkCache_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkCache_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkCache_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkCache_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkCache_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkCache_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkCache_lastErrorXml($this->_cPtr);
	}

	function get_LastEtagFetched($str) {
		CkCache_get_LastEtagFetched($this->_cPtr,$str);
	}

	function lastEtagFetched() {
		return CkCache_lastEtagFetched($this->_cPtr);
	}

	function get_LastExpirationFetchedStr($str) {
		CkCache_get_LastExpirationFetchedStr($this->_cPtr,$str);
	}

	function lastExpirationFetchedStr() {
		return CkCache_lastExpirationFetchedStr($this->_cPtr);
	}

	function get_LastHitExpired() {
		return CkCache_get_LastHitExpired($this->_cPtr);
	}

	function get_LastKeyFetched($str) {
		CkCache_get_LastKeyFetched($this->_cPtr,$str);
	}

	function lastKeyFetched() {
		return CkCache_lastKeyFetched($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkCache_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkCache_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Level() {
		return CkCache_get_Level($this->_cPtr);
	}

	function put_Level($newVal) {
		CkCache_put_Level($this->_cPtr,$newVal);
	}

	function get_NumRoots() {
		return CkCache_get_NumRoots($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkCache_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkCache_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkCache_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkCache_version($this->_cPtr);
	}

	function AddRoot($path) {
		CkCache_AddRoot($this->_cPtr,$path);
	}

	function DeleteAll() {
		return CkCache_DeleteAll($this->_cPtr);
	}

	function DeleteAllExpired() {
		return CkCache_DeleteAllExpired($this->_cPtr);
	}

	function DeleteFromCache($key) {
		return CkCache_DeleteFromCache($this->_cPtr,$key);
	}

	function DeleteOlderDt($dateTime) {
		return CkCache_DeleteOlderDt($this->_cPtr,$dateTime);
	}

	function DeleteOlderStr($dateTimeStr) {
		return CkCache_DeleteOlderStr($this->_cPtr,$dateTimeStr);
	}

	function FetchBd($key,$bd) {
		return CkCache_FetchBd($this->_cPtr,$key,$bd);
	}

	function FetchFromCache($key,$outBytes) {
		return CkCache_FetchFromCache($this->_cPtr,$key,$outBytes);
	}

	function FetchSb($key,$sb) {
		return CkCache_FetchSb($this->_cPtr,$key,$sb);
	}

	function fetchText($key) {
		return CkCache_fetchText($this->_cPtr,$key);
	}

	function getEtag($key) {
		return CkCache_getEtag($this->_cPtr,$key);
	}

	function etag($key) {
		return CkCache_etag($this->_cPtr,$key);
	}

	function GetExpirationDt($key) {
		$r=CkCache_GetExpirationDt($this->_cPtr,$key);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function getExpirationStr($url) {
		return CkCache_getExpirationStr($this->_cPtr,$url);
	}

	function expirationStr($url) {
		return CkCache_expirationStr($this->_cPtr,$url);
	}

	function getFilename($key) {
		return CkCache_getFilename($this->_cPtr,$key);
	}

	function filename($key) {
		return CkCache_filename($this->_cPtr,$key);
	}

	function getRoot($index) {
		return CkCache_getRoot($this->_cPtr,$index);
	}

	function root($index) {
		return CkCache_root($this->_cPtr,$index);
	}

	function IsCached($key) {
		return CkCache_IsCached($this->_cPtr,$key);
	}

	function SaveBd($key,$expiration,$etag,$bd) {
		return CkCache_SaveBd($this->_cPtr,$key,$expiration,$etag,$bd);
	}

	function SaveTextDt($key,$expireDateTime,$eTag,$itemTextData) {
		return CkCache_SaveTextDt($this->_cPtr,$key,$expireDateTime,$eTag,$itemTextData);
	}

	function SaveTextNoExpire($key,$eTag,$itemTextData) {
		return CkCache_SaveTextNoExpire($this->_cPtr,$key,$eTag,$itemTextData);
	}

	function SaveTextStr($key,$expireDateTime,$eTag,$itemTextData) {
		return CkCache_SaveTextStr($this->_cPtr,$key,$expireDateTime,$eTag,$itemTextData);
	}

	function SaveToCacheDt($key,$expireDateTime,$eTag,$itemData) {
		return CkCache_SaveToCacheDt($this->_cPtr,$key,$expireDateTime,$eTag,$itemData);
	}

	function SaveToCacheNoExpire($key,$eTag,$itemData) {
		return CkCache_SaveToCacheNoExpire($this->_cPtr,$key,$eTag,$itemData);
	}

	function SaveToCacheStr($key,$expireDateTime,$eTag,$itemData) {
		return CkCache_SaveToCacheStr($this->_cPtr,$key,$expireDateTime,$eTag,$itemData);
	}

	function UpdateExpirationDt($key,$expireDateTime) {
		return CkCache_UpdateExpirationDt($this->_cPtr,$key,$expireDateTime);
	}

	function UpdateExpirationStr($key,$expireDateTime) {
		return CkCache_UpdateExpirationStr($this->_cPtr,$key,$expireDateTime);
	}
}

class CkCert {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkCert') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkCert();
	}

	function get_Utf8() {
		return CkCert_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkCert_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkCert_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AuthorityKeyId($str) {
		CkCert_get_AuthorityKeyId($this->_cPtr,$str);
	}

	function authorityKeyId() {
		return CkCert_authorityKeyId($this->_cPtr);
	}

	function get_AvoidWindowsPkAccess() {
		return CkCert_get_AvoidWindowsPkAccess($this->_cPtr);
	}

	function put_AvoidWindowsPkAccess($newVal) {
		CkCert_put_AvoidWindowsPkAccess($this->_cPtr,$newVal);
	}

	function get_CertVersion() {
		return CkCert_get_CertVersion($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkCert_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkCert_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkCert_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Expired() {
		return CkCert_get_Expired($this->_cPtr);
	}

	function get_ExtendedKeyUsage($str) {
		CkCert_get_ExtendedKeyUsage($this->_cPtr,$str);
	}

	function extendedKeyUsage() {
		return CkCert_extendedKeyUsage($this->_cPtr);
	}

	function get_ForClientAuthentication() {
		return CkCert_get_ForClientAuthentication($this->_cPtr);
	}

	function get_ForCodeSigning() {
		return CkCert_get_ForCodeSigning($this->_cPtr);
	}

	function get_ForSecureEmail() {
		return CkCert_get_ForSecureEmail($this->_cPtr);
	}

	function get_ForServerAuthentication() {
		return CkCert_get_ForServerAuthentication($this->_cPtr);
	}

	function get_ForTimeStamping() {
		return CkCert_get_ForTimeStamping($this->_cPtr);
	}

	function get_IntendedKeyUsage() {
		return CkCert_get_IntendedKeyUsage($this->_cPtr);
	}

	function get_IsRoot() {
		return CkCert_get_IsRoot($this->_cPtr);
	}

	function get_IssuerC($str) {
		CkCert_get_IssuerC($this->_cPtr,$str);
	}

	function issuerC() {
		return CkCert_issuerC($this->_cPtr);
	}

	function get_IssuerCN($str) {
		CkCert_get_IssuerCN($this->_cPtr,$str);
	}

	function issuerCN() {
		return CkCert_issuerCN($this->_cPtr);
	}

	function get_IssuerDN($str) {
		CkCert_get_IssuerDN($this->_cPtr,$str);
	}

	function issuerDN() {
		return CkCert_issuerDN($this->_cPtr);
	}

	function get_IssuerE($str) {
		CkCert_get_IssuerE($this->_cPtr,$str);
	}

	function issuerE() {
		return CkCert_issuerE($this->_cPtr);
	}

	function get_IssuerL($str) {
		CkCert_get_IssuerL($this->_cPtr,$str);
	}

	function issuerL() {
		return CkCert_issuerL($this->_cPtr);
	}

	function get_IssuerO($str) {
		CkCert_get_IssuerO($this->_cPtr,$str);
	}

	function issuerO() {
		return CkCert_issuerO($this->_cPtr);
	}

	function get_IssuerOU($str) {
		CkCert_get_IssuerOU($this->_cPtr,$str);
	}

	function issuerOU() {
		return CkCert_issuerOU($this->_cPtr);
	}

	function get_IssuerS($str) {
		CkCert_get_IssuerS($this->_cPtr,$str);
	}

	function issuerS() {
		return CkCert_issuerS($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkCert_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkCert_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkCert_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkCert_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkCert_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkCert_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkCert_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkCert_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_OcspUrl($str) {
		CkCert_get_OcspUrl($this->_cPtr,$str);
	}

	function ocspUrl() {
		return CkCert_ocspUrl($this->_cPtr);
	}

	function get_PrivateKeyExportable() {
		return CkCert_get_PrivateKeyExportable($this->_cPtr);
	}

	function get_Revoked() {
		return CkCert_get_Revoked($this->_cPtr);
	}

	function get_Rfc822Name($str) {
		CkCert_get_Rfc822Name($this->_cPtr,$str);
	}

	function rfc822Name() {
		return CkCert_rfc822Name($this->_cPtr);
	}

	function get_SelfSigned() {
		return CkCert_get_SelfSigned($this->_cPtr);
	}

	function get_SerialDecimal($str) {
		CkCert_get_SerialDecimal($this->_cPtr,$str);
	}

	function serialDecimal() {
		return CkCert_serialDecimal($this->_cPtr);
	}

	function get_SerialNumber($str) {
		CkCert_get_SerialNumber($this->_cPtr,$str);
	}

	function serialNumber() {
		return CkCert_serialNumber($this->_cPtr);
	}

	function get_Sha1Thumbprint($str) {
		CkCert_get_Sha1Thumbprint($this->_cPtr,$str);
	}

	function sha1Thumbprint() {
		return CkCert_sha1Thumbprint($this->_cPtr);
	}

	function get_SignatureVerified() {
		return CkCert_get_SignatureVerified($this->_cPtr);
	}

	function get_SmartCardFailReason() {
		return CkCert_get_SmartCardFailReason($this->_cPtr);
	}

	function get_SmartCardNoDialog() {
		return CkCert_get_SmartCardNoDialog($this->_cPtr);
	}

	function put_SmartCardNoDialog($newVal) {
		CkCert_put_SmartCardNoDialog($this->_cPtr,$newVal);
	}

	function get_SmartCardPin($str) {
		CkCert_get_SmartCardPin($this->_cPtr,$str);
	}

	function smartCardPin() {
		return CkCert_smartCardPin($this->_cPtr);
	}

	function put_SmartCardPin($newVal) {
		CkCert_put_SmartCardPin($this->_cPtr,$newVal);
	}

	function get_SubjectAlternativeName($str) {
		CkCert_get_SubjectAlternativeName($this->_cPtr,$str);
	}

	function subjectAlternativeName() {
		return CkCert_subjectAlternativeName($this->_cPtr);
	}

	function get_SubjectC($str) {
		CkCert_get_SubjectC($this->_cPtr,$str);
	}

	function subjectC() {
		return CkCert_subjectC($this->_cPtr);
	}

	function get_SubjectCN($str) {
		CkCert_get_SubjectCN($this->_cPtr,$str);
	}

	function subjectCN() {
		return CkCert_subjectCN($this->_cPtr);
	}

	function get_SubjectDN($str) {
		CkCert_get_SubjectDN($this->_cPtr,$str);
	}

	function subjectDN() {
		return CkCert_subjectDN($this->_cPtr);
	}

	function get_SubjectE($str) {
		CkCert_get_SubjectE($this->_cPtr,$str);
	}

	function subjectE() {
		return CkCert_subjectE($this->_cPtr);
	}

	function get_SubjectKeyId($str) {
		CkCert_get_SubjectKeyId($this->_cPtr,$str);
	}

	function subjectKeyId() {
		return CkCert_subjectKeyId($this->_cPtr);
	}

	function get_SubjectL($str) {
		CkCert_get_SubjectL($this->_cPtr,$str);
	}

	function subjectL() {
		return CkCert_subjectL($this->_cPtr);
	}

	function get_SubjectO($str) {
		CkCert_get_SubjectO($this->_cPtr,$str);
	}

	function subjectO() {
		return CkCert_subjectO($this->_cPtr);
	}

	function get_SubjectOU($str) {
		CkCert_get_SubjectOU($this->_cPtr,$str);
	}

	function subjectOU() {
		return CkCert_subjectOU($this->_cPtr);
	}

	function get_SubjectS($str) {
		CkCert_get_SubjectS($this->_cPtr,$str);
	}

	function subjectS() {
		return CkCert_subjectS($this->_cPtr);
	}

	function get_TrustedRoot() {
		return CkCert_get_TrustedRoot($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkCert_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkCert_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkCert_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_ValidFromStr($str) {
		CkCert_get_ValidFromStr($this->_cPtr,$str);
	}

	function validFromStr() {
		return CkCert_validFromStr($this->_cPtr);
	}

	function get_ValidToStr($str) {
		CkCert_get_ValidToStr($this->_cPtr,$str);
	}

	function validToStr() {
		return CkCert_validToStr($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkCert_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkCert_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkCert_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkCert_version($this->_cPtr);
	}

	function BuildCertChain($certChain) {
		return CkCert_BuildCertChain($this->_cPtr,$certChain);
	}

	function CheckRevoked() {
		return CkCert_CheckRevoked($this->_cPtr);
	}

	function CheckSmartCardPin() {
		return CkCert_CheckSmartCardPin($this->_cPtr);
	}

	function ExportCertDer($outData) {
		return CkCert_ExportCertDer($this->_cPtr,$outData);
	}

	function ExportCertDerBd($cerData) {
		return CkCert_ExportCertDerBd($this->_cPtr,$cerData);
	}

	function ExportCertDerFile($path) {
		return CkCert_ExportCertDerFile($this->_cPtr,$path);
	}

	function exportCertPem() {
		return CkCert_exportCertPem($this->_cPtr);
	}

	function ExportCertPemFile($path) {
		return CkCert_ExportCertPemFile($this->_cPtr,$path);
	}

	function exportCertXml() {
		return CkCert_exportCertXml($this->_cPtr);
	}

	function ExportPrivateKey() {
		$r=CkCert_ExportPrivateKey($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPrivateKey($r);
		}
		return $r;
	}

	function ExportPublicKey() {
		$r=CkCert_ExportPublicKey($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPublicKey($r);
		}
		return $r;
	}

	function ExportToPfxBd($password,$includeCertChain,$pfxData) {
		return CkCert_ExportToPfxBd($this->_cPtr,$password,$includeCertChain,$pfxData);
	}

	function ExportToPfxData($password,$includeCertChain,$outBytes) {
		return CkCert_ExportToPfxData($this->_cPtr,$password,$includeCertChain,$outBytes);
	}

	function ExportToPfxFile($pfxFilename,$pfxPassword,$bIncludeCertChain) {
		return CkCert_ExportToPfxFile($this->_cPtr,$pfxFilename,$pfxPassword,$bIncludeCertChain);
	}

	function FindIssuer() {
		$r=CkCert_FindIssuer($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetCertChain() {
		$r=CkCert_GetCertChain($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCertChain($r);
		}
		return $r;
	}

	function getEncoded() {
		return CkCert_getEncoded($this->_cPtr);
	}

	function encoded() {
		return CkCert_encoded($this->_cPtr);
	}

	function getExtensionAsText($oid) {
		return CkCert_getExtensionAsText($this->_cPtr,$oid);
	}

	function extensionAsText($oid) {
		return CkCert_extensionAsText($this->_cPtr,$oid);
	}

	function getExtensionAsXml($oid) {
		return CkCert_getExtensionAsXml($this->_cPtr,$oid);
	}

	function extensionAsXml($oid) {
		return CkCert_extensionAsXml($this->_cPtr,$oid);
	}

	function GetExtensionBd($oid,$bd) {
		return CkCert_GetExtensionBd($this->_cPtr,$oid,$bd);
	}

	function GetIssuer($issuer) {
		return CkCert_GetIssuer($this->_cPtr,$issuer);
	}

	function GetPrivateKey($privKey) {
		return CkCert_GetPrivateKey($this->_cPtr,$privKey);
	}

	function getPrivateKeyPem() {
		return CkCert_getPrivateKeyPem($this->_cPtr);
	}

	function privateKeyPem() {
		return CkCert_privateKeyPem($this->_cPtr);
	}

	function GetPubKeyDer($preferPkcs1,$bd) {
		return CkCert_GetPubKeyDer($this->_cPtr,$preferPkcs1,$bd);
	}

	function GetPublicKey($pubKey) {
		return CkCert_GetPublicKey($this->_cPtr,$pubKey);
	}

	function GetSignature($bd) {
		return CkCert_GetSignature($this->_cPtr,$bd);
	}

	function getSpkiFingerprint($hashAlg,$encoding) {
		return CkCert_getSpkiFingerprint($this->_cPtr,$hashAlg,$encoding);
	}

	function spkiFingerprint($hashAlg,$encoding) {
		return CkCert_spkiFingerprint($this->_cPtr,$hashAlg,$encoding);
	}

	function getSubjectPart($partNameOrOid) {
		return CkCert_getSubjectPart($this->_cPtr,$partNameOrOid);
	}

	function subjectPart($partNameOrOid) {
		return CkCert_subjectPart($this->_cPtr,$partNameOrOid);
	}

	function GetValidFromDt() {
		$r=CkCert_GetValidFromDt($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetValidToDt() {
		$r=CkCert_GetValidToDt($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function hashOf($part,$hashAlg,$encoding) {
		return CkCert_hashOf($this->_cPtr,$part,$hashAlg,$encoding);
	}

	function HasPrivateKey() {
		return CkCert_HasPrivateKey($this->_cPtr);
	}

	function IsEcdsa() {
		return CkCert_IsEcdsa($this->_cPtr);
	}

	function IsRsa() {
		return CkCert_IsRsa($this->_cPtr);
	}

	function LinkPkcs11($session) {
		return CkCert_LinkPkcs11($this->_cPtr,$session);
	}

	function LoadByCommonName($cn) {
		return CkCert_LoadByCommonName($this->_cPtr,$cn);
	}

	function LoadByEmailAddress($emailAddress) {
		return CkCert_LoadByEmailAddress($this->_cPtr,$emailAddress);
	}

	function LoadByIssuerAndSerialNumber($issuerCN,$serialNumber) {
		return CkCert_LoadByIssuerAndSerialNumber($this->_cPtr,$issuerCN,$serialNumber);
	}

	function LoadBySubjectOid($oid,$value) {
		return CkCert_LoadBySubjectOid($this->_cPtr,$oid,$value);
	}

	function LoadByThumbprint($thumbprint,$encoding) {
		return CkCert_LoadByThumbprint($this->_cPtr,$thumbprint,$encoding);
	}

	function LoadFromBase64($encodedCert) {
		return CkCert_LoadFromBase64($this->_cPtr,$encodedCert);
	}

	function LoadFromBd($certBytes) {
		return CkCert_LoadFromBd($this->_cPtr,$certBytes);
	}

	function LoadFromBinary($data) {
		return CkCert_LoadFromBinary($this->_cPtr,$data);
	}

	function LoadFromFile($path) {
		return CkCert_LoadFromFile($this->_cPtr,$path);
	}

	function LoadFromSmartcard($certSpec) {
		return CkCert_LoadFromSmartcard($this->_cPtr,$certSpec);
	}

	function LoadPem($strPem) {
		return CkCert_LoadPem($this->_cPtr,$strPem);
	}

	function LoadPfxBd($pfxData,$password) {
		return CkCert_LoadPfxBd($this->_cPtr,$pfxData,$password);
	}

	function LoadPfxData($pfxData,$password) {
		return CkCert_LoadPfxData($this->_cPtr,$pfxData,$password);
	}

	function LoadPfxFile($pfxPath,$password) {
		return CkCert_LoadPfxFile($this->_cPtr,$pfxPath,$password);
	}

	function LoadTaskResult($task) {
		return CkCert_LoadTaskResult($this->_cPtr,$task);
	}

	function PemFileToDerFile($fromPath,$toPath) {
		return CkCert_PemFileToDerFile($this->_cPtr,$fromPath,$toPath);
	}

	function SaveToFile($path) {
		return CkCert_SaveToFile($this->_cPtr,$path);
	}

	function SetCloudSigner($json) {
		return CkCert_SetCloudSigner($this->_cPtr,$json);
	}

	function SetCloudSignerAsync($json) {
		$r=CkCert_SetCloudSignerAsync($this->_cPtr,$json);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetFromEncoded($encodedCert) {
		return CkCert_SetFromEncoded($this->_cPtr,$encodedCert);
	}

	function SetPrivateKey($privKey) {
		return CkCert_SetPrivateKey($this->_cPtr,$privKey);
	}

	function SetPrivateKeyPem($privKeyPem) {
		return CkCert_SetPrivateKeyPem($this->_cPtr,$privKeyPem);
	}

	function Unload() {
		return CkCert_Unload($this->_cPtr);
	}

	function UploadToCloud($jsonIn,$jsonOut) {
		return CkCert_UploadToCloud($this->_cPtr,$jsonIn,$jsonOut);
	}

	function UploadToCloudAsync($jsonIn,$jsonOut) {
		$r=CkCert_UploadToCloudAsync($this->_cPtr,$jsonIn,$jsonOut);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UseCertVault($vault) {
		return CkCert_UseCertVault($this->_cPtr,$vault);
	}

	function VerifySignature() {
		return CkCert_VerifySignature($this->_cPtr);
	}

	function x509PKIPathv1() {
		return CkCert_x509PKIPathv1($this->_cPtr);
	}
}

class CkCertChain {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkCertChain') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkCertChain();
	}

	function get_Utf8() {
		return CkCertChain_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkCertChain_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkCertChain_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkCertChain_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkCertChain_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkCertChain_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkCertChain_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkCertChain_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkCertChain_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkCertChain_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkCertChain_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkCertChain_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkCertChain_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumCerts() {
		return CkCertChain_get_NumCerts($this->_cPtr);
	}

	function get_NumExpiredCerts() {
		return CkCertChain_get_NumExpiredCerts($this->_cPtr);
	}

	function get_ReachesRoot() {
		return CkCertChain_get_ReachesRoot($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkCertChain_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkCertChain_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkCertChain_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkCertChain_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkCertChain_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkCertChain_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkCertChain_version($this->_cPtr);
	}

	function CertAt($index,$cert) {
		return CkCertChain_CertAt($this->_cPtr,$index,$cert);
	}

	function GetCert($index) {
		$r=CkCertChain_GetCert($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function IsRootTrusted($trustedRoots) {
		return CkCertChain_IsRootTrusted($this->_cPtr,$trustedRoots);
	}

	function LoadX5C($jwk) {
		return CkCertChain_LoadX5C($this->_cPtr,$jwk);
	}

	function VerifyCertSignatures() {
		return CkCertChain_VerifyCertSignatures($this->_cPtr);
	}

	function x509PKIPathv1() {
		return CkCertChain_x509PKIPathv1($this->_cPtr);
	}
}

class CkCertStore {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkCertStore') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkCertStore();
	}

	function get_Utf8() {
		return CkCertStore_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkCertStore_put_Utf8($this->_cPtr,$b);
	}

	function get_AvoidWindowsPkAccess() {
		return CkCertStore_get_AvoidWindowsPkAccess($this->_cPtr);
	}

	function put_AvoidWindowsPkAccess($newVal) {
		CkCertStore_put_AvoidWindowsPkAccess($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkCertStore_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkCertStore_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkCertStore_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkCertStore_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkCertStore_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkCertStore_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkCertStore_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkCertStore_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkCertStore_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkCertStore_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkCertStore_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumCertificates() {
		return CkCertStore_get_NumCertificates($this->_cPtr);
	}

	function get_SmartCardPin($str) {
		CkCertStore_get_SmartCardPin($this->_cPtr,$str);
	}

	function smartCardPin() {
		return CkCertStore_smartCardPin($this->_cPtr);
	}

	function put_SmartCardPin($newVal) {
		CkCertStore_put_SmartCardPin($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkCertStore_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkCertStore_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkCertStore_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkCertStore_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkCertStore_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkCertStore_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkCertStore_version($this->_cPtr);
	}

	function AddCertificate($cert) {
		return CkCertStore_AddCertificate($this->_cPtr,$cert);
	}

	function CloseCertStore() {
		return CkCertStore_CloseCertStore($this->_cPtr);
	}

	function CreateFileStore($filename) {
		return CkCertStore_CreateFileStore($this->_cPtr,$filename);
	}

	function CreateMemoryStore() {
		return CkCertStore_CreateMemoryStore($this->_cPtr);
	}

	function CreateRegistryStore($regRoot,$regPath) {
		return CkCertStore_CreateRegistryStore($this->_cPtr,$regRoot,$regPath);
	}

	function FindCert($json,$cert) {
		return CkCertStore_FindCert($this->_cPtr,$json,$cert);
	}

	function GetCert($index,$cert) {
		return CkCertStore_GetCert($this->_cPtr,$index,$cert);
	}

	function LoadPemFile($pemPath) {
		return CkCertStore_LoadPemFile($this->_cPtr,$pemPath);
	}

	function LoadPemStr($pemString) {
		return CkCertStore_LoadPemStr($this->_cPtr,$pemString);
	}

	function LoadPfxBd($bd,$password) {
		return CkCertStore_LoadPfxBd($this->_cPtr,$bd,$password);
	}

	function LoadPfxFile($pfxFilename,$password) {
		return CkCertStore_LoadPfxFile($this->_cPtr,$pfxFilename,$password);
	}

	function OpenCurrentUserStore($readOnly) {
		return CkCertStore_OpenCurrentUserStore($this->_cPtr,$readOnly);
	}

	function OpenFileStore($filename,$readOnly) {
		return CkCertStore_OpenFileStore($this->_cPtr,$filename,$readOnly);
	}

	function OpenLocalSystemStore($readOnly) {
		return CkCertStore_OpenLocalSystemStore($this->_cPtr,$readOnly);
	}

	function OpenRegistryStore($regRoot,$regPath,$readOnly) {
		return CkCertStore_OpenRegistryStore($this->_cPtr,$regRoot,$regPath,$readOnly);
	}

	function OpenSmartcard($csp) {
		return CkCertStore_OpenSmartcard($this->_cPtr,$csp);
	}

	function OpenWindowsStore($storeLocation,$storeName,$readOnly) {
		return CkCertStore_OpenWindowsStore($this->_cPtr,$storeLocation,$storeName,$readOnly);
	}

	function RemoveCertificate($cert) {
		return CkCertStore_RemoveCertificate($this->_cPtr,$cert);
	}
}

class CkCharset {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkCharset') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkCharset();
	}

	function get_Utf8() {
		return CkCharset_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkCharset_put_Utf8($this->_cPtr,$b);
	}

	function get_AltToCharset($str) {
		CkCharset_get_AltToCharset($this->_cPtr,$str);
	}

	function altToCharset() {
		return CkCharset_altToCharset($this->_cPtr);
	}

	function put_AltToCharset($newVal) {
		CkCharset_put_AltToCharset($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkCharset_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkCharset_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkCharset_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_ErrorAction() {
		return CkCharset_get_ErrorAction($this->_cPtr);
	}

	function put_ErrorAction($newVal) {
		CkCharset_put_ErrorAction($this->_cPtr,$newVal);
	}

	function get_FromCharset($str) {
		CkCharset_get_FromCharset($this->_cPtr,$str);
	}

	function fromCharset() {
		return CkCharset_fromCharset($this->_cPtr);
	}

	function put_FromCharset($newVal) {
		CkCharset_put_FromCharset($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkCharset_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkCharset_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkCharset_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkCharset_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkCharset_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkCharset_lastErrorXml($this->_cPtr);
	}

	function get_LastInputAsHex($str) {
		CkCharset_get_LastInputAsHex($this->_cPtr,$str);
	}

	function lastInputAsHex() {
		return CkCharset_lastInputAsHex($this->_cPtr);
	}

	function get_LastInputAsQP($str) {
		CkCharset_get_LastInputAsQP($this->_cPtr,$str);
	}

	function lastInputAsQP() {
		return CkCharset_lastInputAsQP($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkCharset_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkCharset_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LastOutputAsHex($str) {
		CkCharset_get_LastOutputAsHex($this->_cPtr,$str);
	}

	function lastOutputAsHex() {
		return CkCharset_lastOutputAsHex($this->_cPtr);
	}

	function get_LastOutputAsQP($str) {
		CkCharset_get_LastOutputAsQP($this->_cPtr,$str);
	}

	function lastOutputAsQP() {
		return CkCharset_lastOutputAsQP($this->_cPtr);
	}

	function get_SaveLast() {
		return CkCharset_get_SaveLast($this->_cPtr);
	}

	function put_SaveLast($newVal) {
		CkCharset_put_SaveLast($this->_cPtr,$newVal);
	}

	function get_ToCharset($str) {
		CkCharset_get_ToCharset($this->_cPtr,$str);
	}

	function toCharset() {
		return CkCharset_toCharset($this->_cPtr);
	}

	function put_ToCharset($newVal) {
		CkCharset_put_ToCharset($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkCharset_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkCharset_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkCharset_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkCharset_version($this->_cPtr);
	}

	function CharsetToCodePage($charsetName) {
		return CkCharset_CharsetToCodePage($this->_cPtr,$charsetName);
	}

	function codePageToCharset($codePage) {
		return CkCharset_codePageToCharset($this->_cPtr,$codePage);
	}

	function ConvertData($inData,$outData) {
		return CkCharset_ConvertData($this->_cPtr,$inData,$outData);
	}

	function ConvertFile($inPath,$destPath) {
		return CkCharset_ConvertFile($this->_cPtr,$inPath,$destPath);
	}

	function ConvertFileNoPreamble($inPath,$destPath) {
		return CkCharset_ConvertFileNoPreamble($this->_cPtr,$inPath,$destPath);
	}

	function ConvertFromUnicode($inData,$outBytes) {
		return CkCharset_ConvertFromUnicode($this->_cPtr,$inData,$outBytes);
	}

	function ConvertFromUtf16($uniData,$outMbData) {
		return CkCharset_ConvertFromUtf16($this->_cPtr,$uniData,$outMbData);
	}

	function ConvertHtml($inData,$outHtml) {
		return CkCharset_ConvertHtml($this->_cPtr,$inData,$outHtml);
	}

	function ConvertHtmlFile($inPath,$destPath) {
		return CkCharset_ConvertHtmlFile($this->_cPtr,$inPath,$destPath);
	}

	function convertToUnicode($inData) {
		return CkCharset_convertToUnicode($this->_cPtr,$inData);
	}

	function ConvertToUtf16($mbData,$outUniData) {
		return CkCharset_ConvertToUtf16($this->_cPtr,$mbData,$outUniData);
	}

	function entityEncodeDec($str) {
		return CkCharset_entityEncodeDec($this->_cPtr,$str);
	}

	function entityEncodeHex($str) {
		return CkCharset_entityEncodeHex($this->_cPtr,$str);
	}

	function getHtmlCharset($inData) {
		return CkCharset_getHtmlCharset($this->_cPtr,$inData);
	}

	function htmlCharset($inData) {
		return CkCharset_htmlCharset($this->_cPtr,$inData);
	}

	function getHtmlFileCharset($htmlFilePath) {
		return CkCharset_getHtmlFileCharset($this->_cPtr,$htmlFilePath);
	}

	function htmlFileCharset($htmlFilePath) {
		return CkCharset_htmlFileCharset($this->_cPtr,$htmlFilePath);
	}

	function htmlDecodeToStr($inStr) {
		return CkCharset_htmlDecodeToStr($this->_cPtr,$inStr);
	}

	function HtmlEntityDecode($inHtml,$outData) {
		return CkCharset_HtmlEntityDecode($this->_cPtr,$inHtml,$outData);
	}

	function HtmlEntityDecodeFile($inPath,$destPath) {
		return CkCharset_HtmlEntityDecodeFile($this->_cPtr,$inPath,$destPath);
	}

	function lowerCase($inStr) {
		return CkCharset_lowerCase($this->_cPtr,$inStr);
	}

	function ReadFile($path,$outData) {
		return CkCharset_ReadFile($this->_cPtr,$path,$outData);
	}

	function readFileToString($path,$charset) {
		return CkCharset_readFileToString($this->_cPtr,$path,$charset);
	}

	function SetErrorString($str,$charset) {
		CkCharset_SetErrorString($this->_cPtr,$str,$charset);
	}

	function upperCase($inStr) {
		return CkCharset_upperCase($this->_cPtr,$inStr);
	}

	function urlDecodeStr($inStr) {
		return CkCharset_urlDecodeStr($this->_cPtr,$inStr);
	}

	function VerifyData($charset,$inData) {
		return CkCharset_VerifyData($this->_cPtr,$charset,$inData);
	}

	function VerifyFile($charset,$path) {
		return CkCharset_VerifyFile($this->_cPtr,$charset,$path);
	}

	function WriteFile($path,$byteData) {
		return CkCharset_WriteFile($this->_cPtr,$path,$byteData);
	}

	function WriteStringToFile($textData,$path,$charset) {
		return CkCharset_WriteStringToFile($this->_cPtr,$textData,$path,$charset);
	}
}

class CkCodeSign {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkCodeSign') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkCodeSign();
	}

	function get_Utf8() {
		return CkCodeSign_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkCodeSign_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkCodeSign_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_DebugLogFilePath($str) {
		CkCodeSign_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkCodeSign_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkCodeSign_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkCodeSign_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkCodeSign_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkCodeSign_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkCodeSign_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkCodeSign_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkCodeSign_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkCodeSign_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkCodeSign_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkCodeSign_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkCodeSign_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkCodeSign_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkCodeSign_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkCodeSign_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkCodeSign_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkCodeSign_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkCodeSign_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkCodeSign_version($this->_cPtr);
	}

	function AddSignature($path,$cert,$options) {
		return CkCodeSign_AddSignature($this->_cPtr,$path,$cert,$options);
	}

	function AddSignatureAsync($path,$cert,$options) {
		$r=CkCodeSign_AddSignatureAsync($this->_cPtr,$path,$cert,$options);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetSignerCert($cert) {
		return CkCodeSign_GetSignerCert($this->_cPtr,$cert);
	}

	function RemoveSignature($path) {
		return CkCodeSign_RemoveSignature($this->_cPtr,$path);
	}

	function VerifySignature($path,$sigInfo) {
		return CkCodeSign_VerifySignature($this->_cPtr,$path,$sigInfo);
	}
}

class CkCompression {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkCompression') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkCompression();
	}

	function get_Utf8() {
		return CkCompression_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkCompression_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkCompression_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_Algorithm($str) {
		CkCompression_get_Algorithm($this->_cPtr,$str);
	}

	function algorithm() {
		return CkCompression_algorithm($this->_cPtr);
	}

	function put_Algorithm($newVal) {
		CkCompression_put_Algorithm($this->_cPtr,$newVal);
	}

	function get_Charset($str) {
		CkCompression_get_Charset($this->_cPtr,$str);
	}

	function charset() {
		return CkCompression_charset($this->_cPtr);
	}

	function put_Charset($newVal) {
		CkCompression_put_Charset($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkCompression_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkCompression_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkCompression_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DeflateLevel() {
		return CkCompression_get_DeflateLevel($this->_cPtr);
	}

	function put_DeflateLevel($newVal) {
		CkCompression_put_DeflateLevel($this->_cPtr,$newVal);
	}

	function get_EncodingMode($str) {
		CkCompression_get_EncodingMode($this->_cPtr,$str);
	}

	function encodingMode() {
		return CkCompression_encodingMode($this->_cPtr);
	}

	function put_EncodingMode($newVal) {
		CkCompression_put_EncodingMode($this->_cPtr,$newVal);
	}

	function get_FirstChunk() {
		return CkCompression_get_FirstChunk($this->_cPtr);
	}

	function put_FirstChunk($newVal) {
		CkCompression_put_FirstChunk($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkCompression_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkCompression_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastChunk() {
		return CkCompression_get_LastChunk($this->_cPtr);
	}

	function put_LastChunk($newVal) {
		CkCompression_put_LastChunk($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkCompression_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkCompression_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkCompression_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkCompression_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkCompression_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkCompression_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkCompression_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkCompression_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkCompression_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkCompression_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkCompression_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkCompression_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkCompression_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkCompression_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkCompression_version($this->_cPtr);
	}

	function BeginCompressBytes($data,$outData) {
		return CkCompression_BeginCompressBytes($this->_cPtr,$data,$outData);
	}

	function beginCompressBytesENC($data) {
		return CkCompression_beginCompressBytesENC($this->_cPtr,$data);
	}

	function BeginCompressString($str,$outData) {
		return CkCompression_BeginCompressString($this->_cPtr,$str,$outData);
	}

	function beginCompressStringENC($str) {
		return CkCompression_beginCompressStringENC($this->_cPtr,$str);
	}

	function BeginDecompressBytes($data,$outData) {
		return CkCompression_BeginDecompressBytes($this->_cPtr,$data,$outData);
	}

	function BeginDecompressBytesENC($str,$outData) {
		return CkCompression_BeginDecompressBytesENC($this->_cPtr,$str,$outData);
	}

	function beginDecompressString($data) {
		return CkCompression_beginDecompressString($this->_cPtr,$data);
	}

	function beginDecompressStringENC($str) {
		return CkCompression_beginDecompressStringENC($this->_cPtr,$str);
	}

	function CompressBd($bd) {
		return CkCompression_CompressBd($this->_cPtr,$bd);
	}

	function CompressBdAsync($bd) {
		$r=CkCompression_CompressBdAsync($this->_cPtr,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressBd2($bdIn,$bdOut) {
		return CkCompression_CompressBd2($this->_cPtr,$bdIn,$bdOut);
	}

	function CompressBd2Async($bdIn,$bdOut) {
		$r=CkCompression_CompressBd2Async($this->_cPtr,$bdIn,$bdOut);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressBytes($data,$outData) {
		return CkCompression_CompressBytes($this->_cPtr,$data,$outData);
	}

	function CompressBytesAsync($data) {
		$r=CkCompression_CompressBytesAsync($this->_cPtr,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function compressBytesENC($data) {
		return CkCompression_compressBytesENC($this->_cPtr,$data);
	}

	function CompressBytesENCAsync($data) {
		$r=CkCompression_CompressBytesENCAsync($this->_cPtr,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressEncryptFile($cryptParams,$srcPath,$destPath) {
		return CkCompression_CompressEncryptFile($this->_cPtr,$cryptParams,$srcPath,$destPath);
	}

	function CompressEncryptFileAsync($cryptParams,$srcPath,$destPath) {
		$r=CkCompression_CompressEncryptFileAsync($this->_cPtr,$cryptParams,$srcPath,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressFile($srcPath,$destPath) {
		return CkCompression_CompressFile($this->_cPtr,$srcPath,$destPath);
	}

	function CompressFileAsync($srcPath,$destPath) {
		$r=CkCompression_CompressFileAsync($this->_cPtr,$srcPath,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressSb($sb,$binData) {
		return CkCompression_CompressSb($this->_cPtr,$sb,$binData);
	}

	function CompressSbAsync($sb,$binData) {
		$r=CkCompression_CompressSbAsync($this->_cPtr,$sb,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressStr($str,$bd) {
		return CkCompression_CompressStr($this->_cPtr,$str,$bd);
	}

	function CompressStrAsync($str,$bd) {
		$r=CkCompression_CompressStrAsync($this->_cPtr,$str,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressStream($strm) {
		return CkCompression_CompressStream($this->_cPtr,$strm);
	}

	function CompressStreamAsync($strm) {
		$r=CkCompression_CompressStreamAsync($this->_cPtr,$strm);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressString($str,$outData) {
		return CkCompression_CompressString($this->_cPtr,$str,$outData);
	}

	function CompressStringAsync($str) {
		$r=CkCompression_CompressStringAsync($this->_cPtr,$str);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function compressStringENC($str) {
		return CkCompression_compressStringENC($this->_cPtr,$str);
	}

	function CompressStringENCAsync($str) {
		$r=CkCompression_CompressStringENCAsync($this->_cPtr,$str);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DecompressBd($bd) {
		return CkCompression_DecompressBd($this->_cPtr,$bd);
	}

	function DecompressBdAsync($bd) {
		$r=CkCompression_DecompressBdAsync($this->_cPtr,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DecompressBd2($bdIn,$bdOut) {
		return CkCompression_DecompressBd2($this->_cPtr,$bdIn,$bdOut);
	}

	function DecompressBd2Async($bdIn,$bdOut) {
		$r=CkCompression_DecompressBd2Async($this->_cPtr,$bdIn,$bdOut);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DecompressBytes($data,$outData) {
		return CkCompression_DecompressBytes($this->_cPtr,$data,$outData);
	}

	function DecompressBytesAsync($data) {
		$r=CkCompression_DecompressBytesAsync($this->_cPtr,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DecompressBytesENC($encodedCompressedData,$outData) {
		return CkCompression_DecompressBytesENC($this->_cPtr,$encodedCompressedData,$outData);
	}

	function DecompressBytesENCAsync($encodedCompressedData) {
		$r=CkCompression_DecompressBytesENCAsync($this->_cPtr,$encodedCompressedData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DecompressFile($srcPath,$destPath) {
		return CkCompression_DecompressFile($this->_cPtr,$srcPath,$destPath);
	}

	function DecompressFileAsync($srcPath,$destPath) {
		$r=CkCompression_DecompressFileAsync($this->_cPtr,$srcPath,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DecompressSb($binData,$sb) {
		return CkCompression_DecompressSb($this->_cPtr,$binData,$sb);
	}

	function DecompressSbAsync($binData,$sb) {
		$r=CkCompression_DecompressSbAsync($this->_cPtr,$binData,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DecompressStream($strm) {
		return CkCompression_DecompressStream($this->_cPtr,$strm);
	}

	function DecompressStreamAsync($strm) {
		$r=CkCompression_DecompressStreamAsync($this->_cPtr,$strm);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function decompressString($data) {
		return CkCompression_decompressString($this->_cPtr,$data);
	}

	function decompressStringENC($encodedCompressedData) {
		return CkCompression_decompressStringENC($this->_cPtr,$encodedCompressedData);
	}

	function DecompressStringENCAsync($encodedCompressedData) {
		$r=CkCompression_DecompressStringENCAsync($this->_cPtr,$encodedCompressedData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DecryptDecompressFile($cryptParams,$srcPath,$destPath) {
		return CkCompression_DecryptDecompressFile($this->_cPtr,$cryptParams,$srcPath,$destPath);
	}

	function DecryptDecompressFileAsync($cryptParams,$srcPath,$destPath) {
		$r=CkCompression_DecryptDecompressFileAsync($this->_cPtr,$cryptParams,$srcPath,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function EndCompressBytes($outData) {
		return CkCompression_EndCompressBytes($this->_cPtr,$outData);
	}

	function endCompressBytesENC() {
		return CkCompression_endCompressBytesENC($this->_cPtr);
	}

	function EndCompressString($outData) {
		return CkCompression_EndCompressString($this->_cPtr,$outData);
	}

	function endCompressStringENC() {
		return CkCompression_endCompressStringENC($this->_cPtr);
	}

	function EndDecompressBytes($outData) {
		return CkCompression_EndDecompressBytes($this->_cPtr,$outData);
	}

	function EndDecompressBytesENC($outData) {
		return CkCompression_EndDecompressBytesENC($this->_cPtr,$outData);
	}

	function endDecompressString() {
		return CkCompression_endDecompressString($this->_cPtr);
	}

	function endDecompressStringENC() {
		return CkCompression_endDecompressStringENC($this->_cPtr);
	}

	function LoadTaskCaller($task) {
		return CkCompression_LoadTaskCaller($this->_cPtr,$task);
	}

	function MoreCompressBytes($data,$outData) {
		return CkCompression_MoreCompressBytes($this->_cPtr,$data,$outData);
	}

	function moreCompressBytesENC($data) {
		return CkCompression_moreCompressBytesENC($this->_cPtr,$data);
	}

	function MoreCompressString($str,$outData) {
		return CkCompression_MoreCompressString($this->_cPtr,$str,$outData);
	}

	function moreCompressStringENC($str) {
		return CkCompression_moreCompressStringENC($this->_cPtr,$str);
	}

	function MoreDecompressBytes($data,$outData) {
		return CkCompression_MoreDecompressBytes($this->_cPtr,$data,$outData);
	}

	function MoreDecompressBytesENC($str,$outData) {
		return CkCompression_MoreDecompressBytesENC($this->_cPtr,$str,$outData);
	}

	function moreDecompressString($data) {
		return CkCompression_moreDecompressString($this->_cPtr,$data);
	}

	function moreDecompressStringENC($str) {
		return CkCompression_moreDecompressStringENC($this->_cPtr,$str);
	}
}

class CkCrypt2 {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkCrypt2') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkCrypt2();
	}

	function get_Utf8() {
		return CkCrypt2_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkCrypt2_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkCrypt2_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkCrypt2_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkCrypt2_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_BCryptWorkFactor() {
		return CkCrypt2_get_BCryptWorkFactor($this->_cPtr);
	}

	function put_BCryptWorkFactor($newVal) {
		CkCrypt2_put_BCryptWorkFactor($this->_cPtr,$newVal);
	}

	function get_BlockSize() {
		return CkCrypt2_get_BlockSize($this->_cPtr);
	}

	function get_CadesEnabled() {
		return CkCrypt2_get_CadesEnabled($this->_cPtr);
	}

	function put_CadesEnabled($newVal) {
		CkCrypt2_put_CadesEnabled($this->_cPtr,$newVal);
	}

	function get_CadesSigPolicyHash($str) {
		CkCrypt2_get_CadesSigPolicyHash($this->_cPtr,$str);
	}

	function cadesSigPolicyHash() {
		return CkCrypt2_cadesSigPolicyHash($this->_cPtr);
	}

	function put_CadesSigPolicyHash($newVal) {
		CkCrypt2_put_CadesSigPolicyHash($this->_cPtr,$newVal);
	}

	function get_CadesSigPolicyId($str) {
		CkCrypt2_get_CadesSigPolicyId($this->_cPtr,$str);
	}

	function cadesSigPolicyId() {
		return CkCrypt2_cadesSigPolicyId($this->_cPtr);
	}

	function put_CadesSigPolicyId($newVal) {
		CkCrypt2_put_CadesSigPolicyId($this->_cPtr,$newVal);
	}

	function get_CadesSigPolicyUri($str) {
		CkCrypt2_get_CadesSigPolicyUri($this->_cPtr,$str);
	}

	function cadesSigPolicyUri() {
		return CkCrypt2_cadesSigPolicyUri($this->_cPtr);
	}

	function put_CadesSigPolicyUri($newVal) {
		CkCrypt2_put_CadesSigPolicyUri($this->_cPtr,$newVal);
	}

	function get_Charset($str) {
		CkCrypt2_get_Charset($this->_cPtr,$str);
	}

	function charset() {
		return CkCrypt2_charset($this->_cPtr);
	}

	function put_Charset($newVal) {
		CkCrypt2_put_Charset($this->_cPtr,$newVal);
	}

	function get_CipherMode($str) {
		CkCrypt2_get_CipherMode($this->_cPtr,$str);
	}

	function cipherMode() {
		return CkCrypt2_cipherMode($this->_cPtr);
	}

	function put_CipherMode($newVal) {
		CkCrypt2_put_CipherMode($this->_cPtr,$newVal);
	}

	function get_CmsOptions($str) {
		CkCrypt2_get_CmsOptions($this->_cPtr,$str);
	}

	function cmsOptions() {
		return CkCrypt2_cmsOptions($this->_cPtr);
	}

	function put_CmsOptions($newVal) {
		CkCrypt2_put_CmsOptions($this->_cPtr,$newVal);
	}

	function get_CryptAlgorithm($str) {
		CkCrypt2_get_CryptAlgorithm($this->_cPtr,$str);
	}

	function cryptAlgorithm() {
		return CkCrypt2_cryptAlgorithm($this->_cPtr);
	}

	function put_CryptAlgorithm($newVal) {
		CkCrypt2_put_CryptAlgorithm($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkCrypt2_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkCrypt2_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkCrypt2_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EncodingMode($str) {
		CkCrypt2_get_EncodingMode($this->_cPtr,$str);
	}

	function encodingMode() {
		return CkCrypt2_encodingMode($this->_cPtr);
	}

	function put_EncodingMode($newVal) {
		CkCrypt2_put_EncodingMode($this->_cPtr,$newVal);
	}

	function get_FirstChunk() {
		return CkCrypt2_get_FirstChunk($this->_cPtr);
	}

	function put_FirstChunk($newVal) {
		CkCrypt2_put_FirstChunk($this->_cPtr,$newVal);
	}

	function get_HashAlgorithm($str) {
		CkCrypt2_get_HashAlgorithm($this->_cPtr,$str);
	}

	function hashAlgorithm() {
		return CkCrypt2_hashAlgorithm($this->_cPtr);
	}

	function put_HashAlgorithm($newVal) {
		CkCrypt2_put_HashAlgorithm($this->_cPtr,$newVal);
	}

	function get_HavalRounds() {
		return CkCrypt2_get_HavalRounds($this->_cPtr);
	}

	function put_HavalRounds($newVal) {
		CkCrypt2_put_HavalRounds($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkCrypt2_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkCrypt2_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_IncludeCertChain() {
		return CkCrypt2_get_IncludeCertChain($this->_cPtr);
	}

	function put_IncludeCertChain($newVal) {
		CkCrypt2_put_IncludeCertChain($this->_cPtr,$newVal);
	}

	function get_InitialCount() {
		return CkCrypt2_get_InitialCount($this->_cPtr);
	}

	function put_InitialCount($newVal) {
		CkCrypt2_put_InitialCount($this->_cPtr,$newVal);
	}

	function get_IterationCount() {
		return CkCrypt2_get_IterationCount($this->_cPtr);
	}

	function put_IterationCount($newVal) {
		CkCrypt2_put_IterationCount($this->_cPtr,$newVal);
	}

	function get_KeyLength() {
		return CkCrypt2_get_KeyLength($this->_cPtr);
	}

	function put_KeyLength($newVal) {
		CkCrypt2_put_KeyLength($this->_cPtr,$newVal);
	}

	function get_LastChunk() {
		return CkCrypt2_get_LastChunk($this->_cPtr);
	}

	function put_LastChunk($newVal) {
		CkCrypt2_put_LastChunk($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkCrypt2_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkCrypt2_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkCrypt2_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkCrypt2_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkCrypt2_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkCrypt2_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkCrypt2_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkCrypt2_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_MacAlgorithm($str) {
		CkCrypt2_get_MacAlgorithm($this->_cPtr,$str);
	}

	function macAlgorithm() {
		return CkCrypt2_macAlgorithm($this->_cPtr);
	}

	function put_MacAlgorithm($newVal) {
		CkCrypt2_put_MacAlgorithm($this->_cPtr,$newVal);
	}

	function get_NumSignerCerts() {
		return CkCrypt2_get_NumSignerCerts($this->_cPtr);
	}

	function get_OaepHash($str) {
		CkCrypt2_get_OaepHash($this->_cPtr,$str);
	}

	function oaepHash() {
		return CkCrypt2_oaepHash($this->_cPtr);
	}

	function put_OaepHash($newVal) {
		CkCrypt2_put_OaepHash($this->_cPtr,$newVal);
	}

	function get_OaepMgfHash($str) {
		CkCrypt2_get_OaepMgfHash($this->_cPtr,$str);
	}

	function oaepMgfHash() {
		return CkCrypt2_oaepMgfHash($this->_cPtr);
	}

	function put_OaepMgfHash($newVal) {
		CkCrypt2_put_OaepMgfHash($this->_cPtr,$newVal);
	}

	function get_OaepPadding() {
		return CkCrypt2_get_OaepPadding($this->_cPtr);
	}

	function put_OaepPadding($newVal) {
		CkCrypt2_put_OaepPadding($this->_cPtr,$newVal);
	}

	function get_PaddingScheme() {
		return CkCrypt2_get_PaddingScheme($this->_cPtr);
	}

	function put_PaddingScheme($newVal) {
		CkCrypt2_put_PaddingScheme($this->_cPtr,$newVal);
	}

	function get_PbesAlgorithm($str) {
		CkCrypt2_get_PbesAlgorithm($this->_cPtr,$str);
	}

	function pbesAlgorithm() {
		return CkCrypt2_pbesAlgorithm($this->_cPtr);
	}

	function put_PbesAlgorithm($newVal) {
		CkCrypt2_put_PbesAlgorithm($this->_cPtr,$newVal);
	}

	function get_PbesPassword($str) {
		CkCrypt2_get_PbesPassword($this->_cPtr,$str);
	}

	function pbesPassword() {
		return CkCrypt2_pbesPassword($this->_cPtr);
	}

	function put_PbesPassword($newVal) {
		CkCrypt2_put_PbesPassword($this->_cPtr,$newVal);
	}

	function get_Pkcs7CryptAlg($str) {
		CkCrypt2_get_Pkcs7CryptAlg($this->_cPtr,$str);
	}

	function pkcs7CryptAlg() {
		return CkCrypt2_pkcs7CryptAlg($this->_cPtr);
	}

	function put_Pkcs7CryptAlg($newVal) {
		CkCrypt2_put_Pkcs7CryptAlg($this->_cPtr,$newVal);
	}

	function get_Rc2EffectiveKeyLength() {
		return CkCrypt2_get_Rc2EffectiveKeyLength($this->_cPtr);
	}

	function put_Rc2EffectiveKeyLength($newVal) {
		CkCrypt2_put_Rc2EffectiveKeyLength($this->_cPtr,$newVal);
	}

	function get_SigningAlg($str) {
		CkCrypt2_get_SigningAlg($this->_cPtr,$str);
	}

	function signingAlg() {
		return CkCrypt2_signingAlg($this->_cPtr);
	}

	function put_SigningAlg($newVal) {
		CkCrypt2_put_SigningAlg($this->_cPtr,$newVal);
	}

	function get_SigningAttributes($str) {
		CkCrypt2_get_SigningAttributes($this->_cPtr,$str);
	}

	function signingAttributes() {
		return CkCrypt2_signingAttributes($this->_cPtr);
	}

	function put_SigningAttributes($newVal) {
		CkCrypt2_put_SigningAttributes($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkCrypt2_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkCrypt2_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkCrypt2_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UuFilename($str) {
		CkCrypt2_get_UuFilename($this->_cPtr,$str);
	}

	function uuFilename() {
		return CkCrypt2_uuFilename($this->_cPtr);
	}

	function put_UuFilename($newVal) {
		CkCrypt2_put_UuFilename($this->_cPtr,$newVal);
	}

	function get_UuMode($str) {
		CkCrypt2_get_UuMode($this->_cPtr,$str);
	}

	function uuMode() {
		return CkCrypt2_uuMode($this->_cPtr);
	}

	function put_UuMode($newVal) {
		CkCrypt2_put_UuMode($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkCrypt2_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkCrypt2_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkCrypt2_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkCrypt2_version($this->_cPtr);
	}

	function AddEncryptCert($cert) {
		CkCrypt2_AddEncryptCert($this->_cPtr,$cert);
	}

	function AddPfxSourceBd($bd,$password) {
		return CkCrypt2_AddPfxSourceBd($this->_cPtr,$bd,$password);
	}

	function AddPfxSourceData($pfxBytes,$pfxPassword) {
		return CkCrypt2_AddPfxSourceData($this->_cPtr,$pfxBytes,$pfxPassword);
	}

	function AddPfxSourceFile($pfxFilePath,$pfxPassword) {
		return CkCrypt2_AddPfxSourceFile($this->_cPtr,$pfxFilePath,$pfxPassword);
	}

	function AddSigningCert($cert) {
		return CkCrypt2_AddSigningCert($this->_cPtr,$cert);
	}

	function aesKeyUnwrap($kek,$wrappedKeyData,$encoding) {
		return CkCrypt2_aesKeyUnwrap($this->_cPtr,$kek,$wrappedKeyData,$encoding);
	}

	function aesKeyUnwrapWithPadding($kek,$wrappedKeyData,$encoding) {
		return CkCrypt2_aesKeyUnwrapWithPadding($this->_cPtr,$kek,$wrappedKeyData,$encoding);
	}

	function aesKeyWrap($kek,$keyData,$encoding) {
		return CkCrypt2_aesKeyWrap($this->_cPtr,$kek,$keyData,$encoding);
	}

	function aesKeyWrapWithPadding($kek,$keyData,$encoding) {
		return CkCrypt2_aesKeyWrapWithPadding($this->_cPtr,$kek,$keyData,$encoding);
	}

	function bCryptHash($password) {
		return CkCrypt2_bCryptHash($this->_cPtr,$password);
	}

	function BCryptVerify($password,$bcryptHash) {
		return CkCrypt2_BCryptVerify($this->_cPtr,$password,$bcryptHash);
	}

	function CkDecryptFile($srcFile,$destFile) {
		return CkCrypt2_CkDecryptFile($this->_cPtr,$srcFile,$destFile);
	}

	function CkDecryptFileAsync($srcFile,$destFile) {
		$r=CkCrypt2_CkDecryptFileAsync($this->_cPtr,$srcFile,$destFile);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CkEncryptFile($srcFile,$destFile) {
		return CkCrypt2_CkEncryptFile($this->_cPtr,$srcFile,$destFile);
	}

	function CkEncryptFileAsync($srcFile,$destFile) {
		$r=CkCrypt2_CkEncryptFileAsync($this->_cPtr,$srcFile,$destFile);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ClearEncryptCerts() {
		CkCrypt2_ClearEncryptCerts($this->_cPtr);
	}

	function ClearSigningCerts() {
		CkCrypt2_ClearSigningCerts($this->_cPtr);
	}

	function CoSign($bdIn,$cert,$bdOut) {
		return CkCrypt2_CoSign($this->_cPtr,$bdIn,$cert,$bdOut);
	}

	function CrcBd($crcAlg,$bd) {
		return CkCrypt2_CrcBd($this->_cPtr,$crcAlg,$bd);
	}

	function CrcBytes($crcAlg,$byteData) {
		return CkCrypt2_CrcBytes($this->_cPtr,$crcAlg,$byteData);
	}

	function CrcFile($crcAlg,$path) {
		return CkCrypt2_CrcFile($this->_cPtr,$crcAlg,$path);
	}

	function CrcFileAsync($crcAlg,$path) {
		$r=CkCrypt2_CrcFileAsync($this->_cPtr,$crcAlg,$path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CreateDetachedSignature($inFilePath,$sigFilePath) {
		return CkCrypt2_CreateDetachedSignature($this->_cPtr,$inFilePath,$sigFilePath);
	}

	function CreateP7M($inFilename,$p7mPath) {
		return CkCrypt2_CreateP7M($this->_cPtr,$inFilename,$p7mPath);
	}

	function CreateP7MAsync($inFilename,$p7mPath) {
		$r=CkCrypt2_CreateP7MAsync($this->_cPtr,$inFilename,$p7mPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CreateP7S($inFilename,$p7sPath) {
		return CkCrypt2_CreateP7S($this->_cPtr,$inFilename,$p7sPath);
	}

	function CreateP7SAsync($inFilename,$p7sPath) {
		$r=CkCrypt2_CreateP7SAsync($this->_cPtr,$inFilename,$p7sPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Decode($str,$encoding,$outData) {
		return CkCrypt2_Decode($this->_cPtr,$str,$encoding,$outData);
	}

	function decodeString($inStr,$charset,$encoding) {
		return CkCrypt2_decodeString($this->_cPtr,$inStr,$charset,$encoding);
	}

	function DecryptBd($bd) {
		return CkCrypt2_DecryptBd($this->_cPtr,$bd);
	}

	function DecryptBytes($data,$outData) {
		return CkCrypt2_DecryptBytes($this->_cPtr,$data,$outData);
	}

	function DecryptBytesENC($str,$outData) {
		return CkCrypt2_DecryptBytesENC($this->_cPtr,$str,$outData);
	}

	function decryptEncoded($encodedEncryptedData) {
		return CkCrypt2_decryptEncoded($this->_cPtr,$encodedEncryptedData);
	}

	function DecryptSb($bdIn,$sbOut) {
		return CkCrypt2_DecryptSb($this->_cPtr,$bdIn,$sbOut);
	}

	function DecryptSecureENC($cipherText,$secureStr) {
		return CkCrypt2_DecryptSecureENC($this->_cPtr,$cipherText,$secureStr);
	}

	function DecryptStream($strm) {
		return CkCrypt2_DecryptStream($this->_cPtr,$strm);
	}

	function DecryptStreamAsync($strm) {
		$r=CkCrypt2_DecryptStreamAsync($this->_cPtr,$strm);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function decryptString($data) {
		return CkCrypt2_decryptString($this->_cPtr,$data);
	}

	function decryptStringENC($str) {
		return CkCrypt2_decryptStringENC($this->_cPtr,$str);
	}

	function encode($byteData,$encoding) {
		return CkCrypt2_encode($this->_cPtr,$byteData,$encoding);
	}

	function encodeInt($value,$numBytes,$littleEndian,$encoding) {
		return CkCrypt2_encodeInt($this->_cPtr,$value,$numBytes,$littleEndian,$encoding);
	}

	function encodeString($strToEncode,$charsetName,$toEncodingName) {
		return CkCrypt2_encodeString($this->_cPtr,$strToEncode,$charsetName,$toEncodingName);
	}

	function EncryptBd($bd) {
		return CkCrypt2_EncryptBd($this->_cPtr,$bd);
	}

	function EncryptBytes($data,$outData) {
		return CkCrypt2_EncryptBytes($this->_cPtr,$data,$outData);
	}

	function encryptBytesENC($data) {
		return CkCrypt2_encryptBytesENC($this->_cPtr,$data);
	}

	function encryptEncoded($str) {
		return CkCrypt2_encryptEncoded($this->_cPtr,$str);
	}

	function EncryptSb($sbIn,$bdOut) {
		return CkCrypt2_EncryptSb($this->_cPtr,$sbIn,$bdOut);
	}

	function encryptSecureENC($secureStr) {
		return CkCrypt2_encryptSecureENC($this->_cPtr,$secureStr);
	}

	function EncryptStream($strm) {
		return CkCrypt2_EncryptStream($this->_cPtr,$strm);
	}

	function EncryptStreamAsync($strm) {
		$r=CkCrypt2_EncryptStreamAsync($this->_cPtr,$strm);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function EncryptString($str,$outData) {
		return CkCrypt2_EncryptString($this->_cPtr,$str,$outData);
	}

	function encryptStringENC($str) {
		return CkCrypt2_encryptStringENC($this->_cPtr,$str);
	}

	function genEncodedSecretKey($password,$encoding) {
		return CkCrypt2_genEncodedSecretKey($this->_cPtr,$password,$encoding);
	}

	function GenerateSecretKey($password,$outData) {
		return CkCrypt2_GenerateSecretKey($this->_cPtr,$password,$outData);
	}

	function generateUuid() {
		return CkCrypt2_generateUuid($this->_cPtr);
	}

	function genRandomBytesENC($numBytes) {
		return CkCrypt2_genRandomBytesENC($this->_cPtr,$numBytes);
	}

	function GetDecryptCert() {
		$r=CkCrypt2_GetDecryptCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function getEncodedAad($encoding) {
		return CkCrypt2_getEncodedAad($this->_cPtr,$encoding);
	}

	function encodedAad($encoding) {
		return CkCrypt2_encodedAad($this->_cPtr,$encoding);
	}

	function getEncodedAuthTag($encoding) {
		return CkCrypt2_getEncodedAuthTag($this->_cPtr,$encoding);
	}

	function encodedAuthTag($encoding) {
		return CkCrypt2_encodedAuthTag($this->_cPtr,$encoding);
	}

	function getEncodedIV($encoding) {
		return CkCrypt2_getEncodedIV($this->_cPtr,$encoding);
	}

	function encodedIV($encoding) {
		return CkCrypt2_encodedIV($this->_cPtr,$encoding);
	}

	function getEncodedKey($encoding) {
		return CkCrypt2_getEncodedKey($this->_cPtr,$encoding);
	}

	function encodedKey($encoding) {
		return CkCrypt2_encodedKey($this->_cPtr,$encoding);
	}

	function getEncodedSalt($encoding) {
		return CkCrypt2_getEncodedSalt($this->_cPtr,$encoding);
	}

	function encodedSalt($encoding) {
		return CkCrypt2_encodedSalt($this->_cPtr,$encoding);
	}

	function GetLastJsonData($json) {
		CkCrypt2_GetLastJsonData($this->_cPtr,$json);
	}

	function getSignatureSigningTimeStr($index) {
		return CkCrypt2_getSignatureSigningTimeStr($this->_cPtr,$index);
	}

	function signatureSigningTimeStr($index) {
		return CkCrypt2_signatureSigningTimeStr($this->_cPtr,$index);
	}

	function GetSignedAttributes($signerIndex,$pkcs7Der,$sbJson) {
		return CkCrypt2_GetSignedAttributes($this->_cPtr,$signerIndex,$pkcs7Der,$sbJson);
	}

	function GetSignerCert($index) {
		$r=CkCrypt2_GetSignerCert($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetSignerCertChain($index) {
		$r=CkCrypt2_GetSignerCertChain($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCertChain($r);
		}
		return $r;
	}

	function hashBdENC($bd) {
		return CkCrypt2_hashBdENC($this->_cPtr,$bd);
	}

	function HashBeginBytes($data) {
		return CkCrypt2_HashBeginBytes($this->_cPtr,$data);
	}

	function HashBeginString($strData) {
		return CkCrypt2_HashBeginString($this->_cPtr,$strData);
	}

	function HashBytes($data,$outData) {
		return CkCrypt2_HashBytes($this->_cPtr,$data,$outData);
	}

	function hashBytesENC($data) {
		return CkCrypt2_hashBytesENC($this->_cPtr,$data);
	}

	function HashChunkBd($firstChunk,$bd) {
		return CkCrypt2_HashChunkBd($this->_cPtr,$firstChunk,$bd);
	}

	function HashFile($path,$outBytes) {
		return CkCrypt2_HashFile($this->_cPtr,$path,$outBytes);
	}

	function HashFileAsync($path) {
		$r=CkCrypt2_HashFileAsync($this->_cPtr,$path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function hashFileENC($path) {
		return CkCrypt2_hashFileENC($this->_cPtr,$path);
	}

	function HashFileENCAsync($path) {
		$r=CkCrypt2_HashFileENCAsync($this->_cPtr,$path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HashFinal($outBytes) {
		return CkCrypt2_HashFinal($this->_cPtr,$outBytes);
	}

	function hashFinalENC() {
		return CkCrypt2_hashFinalENC($this->_cPtr);
	}

	function HashMoreBytes($data) {
		return CkCrypt2_HashMoreBytes($this->_cPtr,$data);
	}

	function HashMoreString($strData) {
		return CkCrypt2_HashMoreString($this->_cPtr,$strData);
	}

	function HashString($str,$outData) {
		return CkCrypt2_HashString($this->_cPtr,$str,$outData);
	}

	function hashStringENC($str) {
		return CkCrypt2_hashStringENC($this->_cPtr,$str);
	}

	function HasSignatureSigningTime($index) {
		return CkCrypt2_HasSignatureSigningTime($this->_cPtr,$index);
	}

	function hotp($secret,$secretEnc,$counterHex,$numDigits,$truncOffset,$hashAlg) {
		return CkCrypt2_hotp($this->_cPtr,$secret,$secretEnc,$counterHex,$numDigits,$truncOffset,$hashAlg);
	}

	function LastDecryptCert($cert) {
		return CkCrypt2_LastDecryptCert($this->_cPtr,$cert);
	}

	function LastJsonData() {
		$r=CkCrypt2_LastJsonData($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LastSignerCert($index,$cert) {
		return CkCrypt2_LastSignerCert($this->_cPtr,$index,$cert);
	}

	function LoadTaskCaller($task) {
		return CkCrypt2_LoadTaskCaller($this->_cPtr,$task);
	}

	function macBdENC($bd) {
		return CkCrypt2_macBdENC($this->_cPtr,$bd);
	}

	function MacBytes($inBytes,$outBytes) {
		return CkCrypt2_MacBytes($this->_cPtr,$inBytes,$outBytes);
	}

	function macBytesENC($inBytes) {
		return CkCrypt2_macBytesENC($this->_cPtr,$inBytes);
	}

	function MacString($inText,$outBytes) {
		return CkCrypt2_MacString($this->_cPtr,$inText,$outBytes);
	}

	function macStringENC($inText) {
		return CkCrypt2_macStringENC($this->_cPtr,$inText);
	}

	function mySqlAesDecrypt($strEncryptedHex,$strPassword) {
		return CkCrypt2_mySqlAesDecrypt($this->_cPtr,$strEncryptedHex,$strPassword);
	}

	function mySqlAesEncrypt($strData,$strPassword) {
		return CkCrypt2_mySqlAesEncrypt($this->_cPtr,$strData,$strPassword);
	}

	function OpaqueSignBd($bd) {
		return CkCrypt2_OpaqueSignBd($this->_cPtr,$bd);
	}

	function OpaqueSignBdAsync($bd) {
		$r=CkCrypt2_OpaqueSignBdAsync($this->_cPtr,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function OpaqueSignBytes($data,$outData) {
		return CkCrypt2_OpaqueSignBytes($this->_cPtr,$data,$outData);
	}

	function OpaqueSignBytesAsync($data) {
		$r=CkCrypt2_OpaqueSignBytesAsync($this->_cPtr,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function opaqueSignBytesENC($data) {
		return CkCrypt2_opaqueSignBytesENC($this->_cPtr,$data);
	}

	function OpaqueSignBytesENCAsync($data) {
		$r=CkCrypt2_OpaqueSignBytesENCAsync($this->_cPtr,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function OpaqueSignString($str,$outData) {
		return CkCrypt2_OpaqueSignString($this->_cPtr,$str,$outData);
	}

	function OpaqueSignStringAsync($str) {
		$r=CkCrypt2_OpaqueSignStringAsync($this->_cPtr,$str);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function opaqueSignStringENC($str) {
		return CkCrypt2_opaqueSignStringENC($this->_cPtr,$str);
	}

	function OpaqueSignStringENCAsync($str) {
		$r=CkCrypt2_OpaqueSignStringENCAsync($this->_cPtr,$str);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function OpaqueVerifyBd($bd) {
		return CkCrypt2_OpaqueVerifyBd($this->_cPtr,$bd);
	}

	function OpaqueVerifyBytes($p7m,$outOriginal) {
		return CkCrypt2_OpaqueVerifyBytes($this->_cPtr,$p7m,$outOriginal);
	}

	function OpaqueVerifyBytesENC($p7m,$outOriginal) {
		return CkCrypt2_OpaqueVerifyBytesENC($this->_cPtr,$p7m,$outOriginal);
	}

	function opaqueVerifyString($p7m) {
		return CkCrypt2_opaqueVerifyString($this->_cPtr,$p7m);
	}

	function opaqueVerifyStringENC($p7m) {
		return CkCrypt2_opaqueVerifyStringENC($this->_cPtr,$p7m);
	}

	function pbkdf1($password,$charset,$hashAlg,$salt,$iterationCount,$outputKeyBitLen,$encoding) {
		return CkCrypt2_pbkdf1($this->_cPtr,$password,$charset,$hashAlg,$salt,$iterationCount,$outputKeyBitLen,$encoding);
	}

	function pbkdf2($password,$charset,$hashAlg,$salt,$iterationCount,$outputKeyBitLen,$encoding) {
		return CkCrypt2_pbkdf2($this->_cPtr,$password,$charset,$hashAlg,$salt,$iterationCount,$outputKeyBitLen,$encoding);
	}

	function RandomizeIV() {
		CkCrypt2_RandomizeIV($this->_cPtr);
	}

	function RandomizeKey() {
		CkCrypt2_RandomizeKey($this->_cPtr);
	}

	function reEncode($encodedData,$fromEncoding,$toEncoding) {
		return CkCrypt2_reEncode($this->_cPtr,$encodedData,$fromEncoding,$toEncoding);
	}

	function SetDecryptCert($cert) {
		return CkCrypt2_SetDecryptCert($this->_cPtr,$cert);
	}

	function SetDecryptCert2($cert,$key) {
		return CkCrypt2_SetDecryptCert2($this->_cPtr,$cert,$key);
	}

	function SetEncodedAad($aadStr,$encoding) {
		return CkCrypt2_SetEncodedAad($this->_cPtr,$aadStr,$encoding);
	}

	function SetEncodedAuthTag($authTagStr,$encoding) {
		return CkCrypt2_SetEncodedAuthTag($this->_cPtr,$authTagStr,$encoding);
	}

	function SetEncodedIV($ivStr,$encoding) {
		CkCrypt2_SetEncodedIV($this->_cPtr,$ivStr,$encoding);
	}

	function SetEncodedKey($keyStr,$encoding) {
		CkCrypt2_SetEncodedKey($this->_cPtr,$keyStr,$encoding);
	}

	function SetEncodedSalt($saltStr,$encoding) {
		CkCrypt2_SetEncodedSalt($this->_cPtr,$saltStr,$encoding);
	}

	function SetEncryptCert($cert) {
		return CkCrypt2_SetEncryptCert($this->_cPtr,$cert);
	}

	function SetMacKeyBytes($keyBytes) {
		return CkCrypt2_SetMacKeyBytes($this->_cPtr,$keyBytes);
	}

	function SetMacKeyEncoded($key,$encoding) {
		return CkCrypt2_SetMacKeyEncoded($this->_cPtr,$key,$encoding);
	}

	function SetMacKeyString($key) {
		return CkCrypt2_SetMacKeyString($this->_cPtr,$key);
	}

	function SetSecretKeyViaPassword($password) {
		CkCrypt2_SetSecretKeyViaPassword($this->_cPtr,$password);
	}

	function SetSigningCert($cert) {
		return CkCrypt2_SetSigningCert($this->_cPtr,$cert);
	}

	function SetSigningCert2($cert,$privateKey) {
		return CkCrypt2_SetSigningCert2($this->_cPtr,$cert,$privateKey);
	}

	function SetTsaHttpObj($http) {
		CkCrypt2_SetTsaHttpObj($this->_cPtr,$http);
	}

	function SetVerifyCert($cert) {
		return CkCrypt2_SetVerifyCert($this->_cPtr,$cert);
	}

	function signBdENC($dataToSign) {
		return CkCrypt2_signBdENC($this->_cPtr,$dataToSign);
	}

	function SignBdENCAsync($dataToSign) {
		$r=CkCrypt2_SignBdENCAsync($this->_cPtr,$dataToSign);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SignBytes($data,$outData) {
		return CkCrypt2_SignBytes($this->_cPtr,$data,$outData);
	}

	function SignBytesAsync($data) {
		$r=CkCrypt2_SignBytesAsync($this->_cPtr,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function signBytesENC($data) {
		return CkCrypt2_signBytesENC($this->_cPtr,$data);
	}

	function SignBytesENCAsync($data) {
		$r=CkCrypt2_SignBytesENCAsync($this->_cPtr,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function signHashENC($encodedHash,$hashAlg,$hashEncoding) {
		return CkCrypt2_signHashENC($this->_cPtr,$encodedHash,$hashAlg,$hashEncoding);
	}

	function SignHashENCAsync($encodedHash,$hashAlg,$hashEncoding) {
		$r=CkCrypt2_SignHashENCAsync($this->_cPtr,$encodedHash,$hashAlg,$hashEncoding);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function signSbENC($sb) {
		return CkCrypt2_signSbENC($this->_cPtr,$sb);
	}

	function SignSbENCAsync($sb) {
		$r=CkCrypt2_SignSbENCAsync($this->_cPtr,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SignString($str,$outData) {
		return CkCrypt2_SignString($this->_cPtr,$str,$outData);
	}

	function SignStringAsync($str) {
		$r=CkCrypt2_SignStringAsync($this->_cPtr,$str);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function signStringENC($str) {
		return CkCrypt2_signStringENC($this->_cPtr,$str);
	}

	function SignStringENCAsync($str) {
		$r=CkCrypt2_SignStringENCAsync($this->_cPtr,$str);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function totp($secret,$secretEnc,$t0,$tNow,$tStep,$numDigits,$truncOffset,$hashAlg) {
		return CkCrypt2_totp($this->_cPtr,$secret,$secretEnc,$t0,$tNow,$tStep,$numDigits,$truncOffset,$hashAlg);
	}

	function UseCertVault($vault) {
		return CkCrypt2_UseCertVault($this->_cPtr,$vault);
	}

	function VerifyBdENC($data,$encodedSig) {
		return CkCrypt2_VerifyBdENC($this->_cPtr,$data,$encodedSig);
	}

	function VerifyBytes($data,$sig) {
		return CkCrypt2_VerifyBytes($this->_cPtr,$data,$sig);
	}

	function VerifyBytesENC($data,$encodedSig) {
		return CkCrypt2_VerifyBytesENC($this->_cPtr,$data,$encodedSig);
	}

	function VerifyDetachedSignature($inFilename,$p7sFilename) {
		return CkCrypt2_VerifyDetachedSignature($this->_cPtr,$inFilename,$p7sFilename);
	}

	function VerifyP7M($p7mPath,$destPath) {
		return CkCrypt2_VerifyP7M($this->_cPtr,$p7mPath,$destPath);
	}

	function VerifyP7S($originalDataPath,$p7sPath) {
		return CkCrypt2_VerifyP7S($this->_cPtr,$originalDataPath,$p7sPath);
	}

	function VerifySbENC($sb,$encodedSig) {
		return CkCrypt2_VerifySbENC($this->_cPtr,$sb,$encodedSig);
	}

	function VerifyString($str,$sig) {
		return CkCrypt2_VerifyString($this->_cPtr,$str,$sig);
	}

	function VerifyStringENC($str,$encodedSig) {
		return CkCrypt2_VerifyStringENC($this->_cPtr,$str,$encodedSig);
	}

	function XtsSetDataUnitNumber($loUint32,$hiUint32) {
		CkCrypt2_XtsSetDataUnitNumber($this->_cPtr,$loUint32,$hiUint32);
	}

	function XtsSetEncodedTweakKey($key,$encoding) {
		CkCrypt2_XtsSetEncodedTweakKey($this->_cPtr,$key,$encoding);
	}

	function XtsSetEncodedTweakValue($tweak,$encoding) {
		CkCrypt2_XtsSetEncodedTweakValue($this->_cPtr,$tweak,$encoding);
	}
}

class CkCsr {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkCsr') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkCsr();
	}

	function get_Utf8() {
		return CkCsr_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkCsr_put_Utf8($this->_cPtr,$b);
	}

	function get_CommonName($str) {
		CkCsr_get_CommonName($this->_cPtr,$str);
	}

	function commonName() {
		return CkCsr_commonName($this->_cPtr);
	}

	function put_CommonName($newVal) {
		CkCsr_put_CommonName($this->_cPtr,$newVal);
	}

	function get_Company($str) {
		CkCsr_get_Company($this->_cPtr,$str);
	}

	function company() {
		return CkCsr_company($this->_cPtr);
	}

	function put_Company($newVal) {
		CkCsr_put_Company($this->_cPtr,$newVal);
	}

	function get_CompanyDivision($str) {
		CkCsr_get_CompanyDivision($this->_cPtr,$str);
	}

	function companyDivision() {
		return CkCsr_companyDivision($this->_cPtr);
	}

	function put_CompanyDivision($newVal) {
		CkCsr_put_CompanyDivision($this->_cPtr,$newVal);
	}

	function get_Country($str) {
		CkCsr_get_Country($this->_cPtr,$str);
	}

	function country() {
		return CkCsr_country($this->_cPtr);
	}

	function put_Country($newVal) {
		CkCsr_put_Country($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkCsr_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkCsr_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkCsr_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EmailAddress($str) {
		CkCsr_get_EmailAddress($this->_cPtr,$str);
	}

	function emailAddress() {
		return CkCsr_emailAddress($this->_cPtr);
	}

	function put_EmailAddress($newVal) {
		CkCsr_put_EmailAddress($this->_cPtr,$newVal);
	}

	function get_HashAlgorithm($str) {
		CkCsr_get_HashAlgorithm($this->_cPtr,$str);
	}

	function hashAlgorithm() {
		return CkCsr_hashAlgorithm($this->_cPtr);
	}

	function put_HashAlgorithm($newVal) {
		CkCsr_put_HashAlgorithm($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkCsr_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkCsr_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkCsr_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkCsr_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkCsr_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkCsr_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkCsr_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkCsr_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Locality($str) {
		CkCsr_get_Locality($this->_cPtr,$str);
	}

	function locality() {
		return CkCsr_locality($this->_cPtr);
	}

	function put_Locality($newVal) {
		CkCsr_put_Locality($this->_cPtr,$newVal);
	}

	function get_MgfHashAlg($str) {
		CkCsr_get_MgfHashAlg($this->_cPtr,$str);
	}

	function mgfHashAlg() {
		return CkCsr_mgfHashAlg($this->_cPtr);
	}

	function put_MgfHashAlg($newVal) {
		CkCsr_put_MgfHashAlg($this->_cPtr,$newVal);
	}

	function get_PssPadding() {
		return CkCsr_get_PssPadding($this->_cPtr);
	}

	function put_PssPadding($newVal) {
		CkCsr_put_PssPadding($this->_cPtr,$newVal);
	}

	function get_State($str) {
		CkCsr_get_State($this->_cPtr,$str);
	}

	function state() {
		return CkCsr_state($this->_cPtr);
	}

	function put_State($newVal) {
		CkCsr_put_State($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkCsr_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkCsr_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkCsr_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkCsr_version($this->_cPtr);
	}

	function AddSan($sanType,$sanValue) {
		return CkCsr_AddSan($this->_cPtr,$sanType,$sanValue);
	}

	function GenCsrBd($privKey,$csrData) {
		return CkCsr_GenCsrBd($this->_cPtr,$privKey,$csrData);
	}

	function genCsrPem($privKey) {
		return CkCsr_genCsrPem($this->_cPtr,$privKey);
	}

	function GetExtensionRequest($extensionReqXml) {
		return CkCsr_GetExtensionRequest($this->_cPtr,$extensionReqXml);
	}

	function GetPublicKey($pubkey) {
		return CkCsr_GetPublicKey($this->_cPtr,$pubkey);
	}

	function GetSans($sans) {
		return CkCsr_GetSans($this->_cPtr,$sans);
	}

	function getSubjectField($oid) {
		return CkCsr_getSubjectField($this->_cPtr,$oid);
	}

	function subjectField($oid) {
		return CkCsr_subjectField($this->_cPtr,$oid);
	}

	function LoadCsrPem($csrPemStr) {
		return CkCsr_LoadCsrPem($this->_cPtr,$csrPemStr);
	}

	function SetExtensionRequest($extensionReqXml) {
		return CkCsr_SetExtensionRequest($this->_cPtr,$extensionReqXml);
	}

	function SetSubjectField($oid,$value,$asnType) {
		return CkCsr_SetSubjectField($this->_cPtr,$oid,$value,$asnType);
	}

	function VerifyCsr() {
		return CkCsr_VerifyCsr($this->_cPtr);
	}
}

class CkCsv {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkCsv') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkCsv();
	}

	function get_Utf8() {
		return CkCsv_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkCsv_put_Utf8($this->_cPtr,$b);
	}

	function get_AutoTrim() {
		return CkCsv_get_AutoTrim($this->_cPtr);
	}

	function put_AutoTrim($newVal) {
		CkCsv_put_AutoTrim($this->_cPtr,$newVal);
	}

	function get_Crlf() {
		return CkCsv_get_Crlf($this->_cPtr);
	}

	function put_Crlf($newVal) {
		CkCsv_put_Crlf($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkCsv_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkCsv_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkCsv_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Delimiter($str) {
		CkCsv_get_Delimiter($this->_cPtr,$str);
	}

	function delimiter() {
		return CkCsv_delimiter($this->_cPtr);
	}

	function put_Delimiter($newVal) {
		CkCsv_put_Delimiter($this->_cPtr,$newVal);
	}

	function get_EnableQuotes() {
		return CkCsv_get_EnableQuotes($this->_cPtr);
	}

	function put_EnableQuotes($newVal) {
		CkCsv_put_EnableQuotes($this->_cPtr,$newVal);
	}

	function get_EscapeBackslash() {
		return CkCsv_get_EscapeBackslash($this->_cPtr);
	}

	function put_EscapeBackslash($newVal) {
		CkCsv_put_EscapeBackslash($this->_cPtr,$newVal);
	}

	function get_HasColumnNames() {
		return CkCsv_get_HasColumnNames($this->_cPtr);
	}

	function put_HasColumnNames($newVal) {
		CkCsv_put_HasColumnNames($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkCsv_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkCsv_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkCsv_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkCsv_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkCsv_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkCsv_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkCsv_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkCsv_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumColumns() {
		return CkCsv_get_NumColumns($this->_cPtr);
	}

	function get_NumRows() {
		return CkCsv_get_NumRows($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkCsv_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkCsv_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkCsv_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkCsv_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkCsv_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkCsv_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkCsv_version($this->_cPtr);
	}

	function get_XlsxDateFormat($str) {
		CkCsv_get_XlsxDateFormat($this->_cPtr,$str);
	}

	function xlsxDateFormat() {
		return CkCsv_xlsxDateFormat($this->_cPtr);
	}

	function put_XlsxDateFormat($newVal) {
		CkCsv_put_XlsxDateFormat($this->_cPtr,$newVal);
	}

	function DeleteColumn($index) {
		return CkCsv_DeleteColumn($this->_cPtr,$index);
	}

	function DeleteColumnByName($columnName) {
		return CkCsv_DeleteColumnByName($this->_cPtr,$columnName);
	}

	function DeleteRow($index) {
		return CkCsv_DeleteRow($this->_cPtr,$index);
	}

	function getCell($row,$col) {
		return CkCsv_getCell($this->_cPtr,$row,$col);
	}

	function cell($row,$col) {
		return CkCsv_cell($this->_cPtr,$row,$col);
	}

	function getCellByName($rowIndex,$columnName) {
		return CkCsv_getCellByName($this->_cPtr,$rowIndex,$columnName);
	}

	function cellByName($rowIndex,$columnName) {
		return CkCsv_cellByName($this->_cPtr,$rowIndex,$columnName);
	}

	function getColumnName($index) {
		return CkCsv_getColumnName($this->_cPtr,$index);
	}

	function columnName($index) {
		return CkCsv_columnName($this->_cPtr,$index);
	}

	function GetIndex($columnName) {
		return CkCsv_GetIndex($this->_cPtr,$columnName);
	}

	function GetNumCols($row) {
		return CkCsv_GetNumCols($this->_cPtr,$row);
	}

	function InsertColumn($index) {
		return CkCsv_InsertColumn($this->_cPtr,$index);
	}

	function LoadFile($path) {
		return CkCsv_LoadFile($this->_cPtr,$path);
	}

	function LoadFile2($filename,$charset) {
		return CkCsv_LoadFile2($this->_cPtr,$filename,$charset);
	}

	function LoadFromString($csvData) {
		return CkCsv_LoadFromString($this->_cPtr,$csvData);
	}

	function RowMatches($rowIndex,$matchPattern,$caseSensitive) {
		return CkCsv_RowMatches($this->_cPtr,$rowIndex,$matchPattern,$caseSensitive);
	}

	function SaveFile($path) {
		return CkCsv_SaveFile($this->_cPtr,$path);
	}

	function SaveFile2($filename,$charset) {
		return CkCsv_SaveFile2($this->_cPtr,$filename,$charset);
	}

	function SaveToSb($sb) {
		return CkCsv_SaveToSb($this->_cPtr,$sb);
	}

	function saveToString() {
		return CkCsv_saveToString($this->_cPtr);
	}

	function SetCell($row,$col,$content) {
		return CkCsv_SetCell($this->_cPtr,$row,$col,$content);
	}

	function SetCellByName($rowIndex,$columnName,$contentStr) {
		return CkCsv_SetCellByName($this->_cPtr,$rowIndex,$columnName,$contentStr);
	}

	function SetColumnName($index,$columnName) {
		return CkCsv_SetColumnName($this->_cPtr,$index,$columnName);
	}

	function SortByColumn($columnName,$ascending,$caseSensitive) {
		return CkCsv_SortByColumn($this->_cPtr,$columnName,$ascending,$caseSensitive);
	}

	function SortByColumnIndex($index,$ascending,$caseSensitive) {
		return CkCsv_SortByColumnIndex($this->_cPtr,$index,$ascending,$caseSensitive);
	}

	function XlsxGetSheets($xlsx,$sheetNames) {
		return CkCsv_XlsxGetSheets($this->_cPtr,$xlsx,$sheetNames);
	}

	function XlsxLoadSheet($zip,$sheetName) {
		return CkCsv_XlsxLoadSheet($this->_cPtr,$zip,$sheetName);
	}
}

class CkDh {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkDh') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkDh();
	}

	function get_Utf8() {
		return CkDh_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkDh_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkDh_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkDh_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkDh_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_G() {
		return CkDh_get_G($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkDh_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkDh_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkDh_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkDh_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkDh_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkDh_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkDh_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkDh_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_P($str) {
		CkDh_get_P($this->_cPtr,$str);
	}

	function p() {
		return CkDh_p($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkDh_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkDh_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkDh_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkDh_version($this->_cPtr);
	}

	function createE($numBits) {
		return CkDh_createE($this->_cPtr,$numBits);
	}

	function findK($E) {
		return CkDh_findK($this->_cPtr,$E);
	}

	function GenPG($numBits,$G) {
		return CkDh_GenPG($this->_cPtr,$numBits,$G);
	}

	function SetPG($p,$g) {
		return CkDh_SetPG($this->_cPtr,$p,$g);
	}

	function UseKnownPrime($index) {
		CkDh_UseKnownPrime($this->_cPtr,$index);
	}
}

class CkDirTree {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkDirTree') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkDirTree();
	}

	function get_Utf8() {
		return CkDirTree_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkDirTree_put_Utf8($this->_cPtr,$b);
	}

	function get_BaseDir($str) {
		CkDirTree_get_BaseDir($this->_cPtr,$str);
	}

	function baseDir() {
		return CkDirTree_baseDir($this->_cPtr);
	}

	function put_BaseDir($newVal) {
		CkDirTree_put_BaseDir($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkDirTree_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkDirTree_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkDirTree_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DoneIterating() {
		return CkDirTree_get_DoneIterating($this->_cPtr);
	}

	function get_FileSize32() {
		return CkDirTree_get_FileSize32($this->_cPtr);
	}

	function get_FileSize64() {
		return CkDirTree_get_FileSize64($this->_cPtr);
	}

	function get_FileSizeStr($str) {
		CkDirTree_get_FileSizeStr($this->_cPtr,$str);
	}

	function fileSizeStr() {
		return CkDirTree_fileSizeStr($this->_cPtr);
	}

	function get_FullPath($str) {
		CkDirTree_get_FullPath($this->_cPtr,$str);
	}

	function fullPath() {
		return CkDirTree_fullPath($this->_cPtr);
	}

	function get_FullUncPath($str) {
		CkDirTree_get_FullUncPath($this->_cPtr,$str);
	}

	function fullUncPath() {
		return CkDirTree_fullUncPath($this->_cPtr);
	}

	function get_IsDirectory() {
		return CkDirTree_get_IsDirectory($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkDirTree_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkDirTree_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkDirTree_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkDirTree_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkDirTree_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkDirTree_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkDirTree_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkDirTree_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Recurse() {
		return CkDirTree_get_Recurse($this->_cPtr);
	}

	function put_Recurse($newVal) {
		CkDirTree_put_Recurse($this->_cPtr,$newVal);
	}

	function get_RelativePath($str) {
		CkDirTree_get_RelativePath($this->_cPtr,$str);
	}

	function relativePath() {
		return CkDirTree_relativePath($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkDirTree_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkDirTree_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkDirTree_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkDirTree_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkDirTree_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkDirTree_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkDirTree_version($this->_cPtr);
	}

	function AdvancePosition() {
		return CkDirTree_AdvancePosition($this->_cPtr);
	}

	function BeginIterate() {
		return CkDirTree_BeginIterate($this->_cPtr);
	}
}

class CkDkim {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkDkim') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkDkim();
	}

	function get_Utf8() {
		return CkDkim_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkDkim_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkDkim_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkDkim_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkDkim_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkDkim_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkDkim_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkDkim_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DkimAlg($str) {
		CkDkim_get_DkimAlg($this->_cPtr,$str);
	}

	function dkimAlg() {
		return CkDkim_dkimAlg($this->_cPtr);
	}

	function put_DkimAlg($newVal) {
		CkDkim_put_DkimAlg($this->_cPtr,$newVal);
	}

	function get_DkimBodyLengthCount() {
		return CkDkim_get_DkimBodyLengthCount($this->_cPtr);
	}

	function put_DkimBodyLengthCount($newVal) {
		CkDkim_put_DkimBodyLengthCount($this->_cPtr,$newVal);
	}

	function get_DkimCanon($str) {
		CkDkim_get_DkimCanon($this->_cPtr,$str);
	}

	function dkimCanon() {
		return CkDkim_dkimCanon($this->_cPtr);
	}

	function put_DkimCanon($newVal) {
		CkDkim_put_DkimCanon($this->_cPtr,$newVal);
	}

	function get_DkimDomain($str) {
		CkDkim_get_DkimDomain($this->_cPtr,$str);
	}

	function dkimDomain() {
		return CkDkim_dkimDomain($this->_cPtr);
	}

	function put_DkimDomain($newVal) {
		CkDkim_put_DkimDomain($this->_cPtr,$newVal);
	}

	function get_DkimHeaders($str) {
		CkDkim_get_DkimHeaders($this->_cPtr,$str);
	}

	function dkimHeaders() {
		return CkDkim_dkimHeaders($this->_cPtr);
	}

	function put_DkimHeaders($newVal) {
		CkDkim_put_DkimHeaders($this->_cPtr,$newVal);
	}

	function get_DkimSelector($str) {
		CkDkim_get_DkimSelector($this->_cPtr,$str);
	}

	function dkimSelector() {
		return CkDkim_dkimSelector($this->_cPtr);
	}

	function put_DkimSelector($newVal) {
		CkDkim_put_DkimSelector($this->_cPtr,$newVal);
	}

	function get_DomainKeyAlg($str) {
		CkDkim_get_DomainKeyAlg($this->_cPtr,$str);
	}

	function domainKeyAlg() {
		return CkDkim_domainKeyAlg($this->_cPtr);
	}

	function put_DomainKeyAlg($newVal) {
		CkDkim_put_DomainKeyAlg($this->_cPtr,$newVal);
	}

	function get_DomainKeyCanon($str) {
		CkDkim_get_DomainKeyCanon($this->_cPtr,$str);
	}

	function domainKeyCanon() {
		return CkDkim_domainKeyCanon($this->_cPtr);
	}

	function put_DomainKeyCanon($newVal) {
		CkDkim_put_DomainKeyCanon($this->_cPtr,$newVal);
	}

	function get_DomainKeyDomain($str) {
		CkDkim_get_DomainKeyDomain($this->_cPtr,$str);
	}

	function domainKeyDomain() {
		return CkDkim_domainKeyDomain($this->_cPtr);
	}

	function put_DomainKeyDomain($newVal) {
		CkDkim_put_DomainKeyDomain($this->_cPtr,$newVal);
	}

	function get_DomainKeyHeaders($str) {
		CkDkim_get_DomainKeyHeaders($this->_cPtr,$str);
	}

	function domainKeyHeaders() {
		return CkDkim_domainKeyHeaders($this->_cPtr);
	}

	function put_DomainKeyHeaders($newVal) {
		CkDkim_put_DomainKeyHeaders($this->_cPtr,$newVal);
	}

	function get_DomainKeySelector($str) {
		CkDkim_get_DomainKeySelector($this->_cPtr,$str);
	}

	function domainKeySelector() {
		return CkDkim_domainKeySelector($this->_cPtr);
	}

	function put_DomainKeySelector($newVal) {
		CkDkim_put_DomainKeySelector($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkDkim_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkDkim_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkDkim_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkDkim_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkDkim_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkDkim_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkDkim_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkDkim_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkDkim_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkDkim_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkDkim_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkDkim_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_VerifyInfo($str) {
		CkDkim_get_VerifyInfo($this->_cPtr,$str);
	}

	function verifyInfo() {
		return CkDkim_verifyInfo($this->_cPtr);
	}

	function get_Version($str) {
		CkDkim_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkDkim_version($this->_cPtr);
	}

	function DkimSign($mimeData) {
		return CkDkim_DkimSign($this->_cPtr,$mimeData);
	}

	function DkimVerify($sigIndex,$mimeData) {
		return CkDkim_DkimVerify($this->_cPtr,$sigIndex,$mimeData);
	}

	function DomainKeySign($mimeData) {
		return CkDkim_DomainKeySign($this->_cPtr,$mimeData);
	}

	function DomainKeyVerify($sigIndex,$mimeData) {
		return CkDkim_DomainKeyVerify($this->_cPtr,$sigIndex,$mimeData);
	}

	function LoadPublicKey($selector,$domain,$publicKey) {
		return CkDkim_LoadPublicKey($this->_cPtr,$selector,$domain,$publicKey);
	}

	function LoadPublicKeyFile($selector,$domain,$publicKeyFilepath) {
		return CkDkim_LoadPublicKeyFile($this->_cPtr,$selector,$domain,$publicKeyFilepath);
	}

	function LoadTaskCaller($task) {
		return CkDkim_LoadTaskCaller($this->_cPtr,$task);
	}

	function NumDkimSigs($mimeData) {
		return CkDkim_NumDkimSigs($this->_cPtr,$mimeData);
	}

	function NumDomainKeySigs($mimeData) {
		return CkDkim_NumDomainKeySigs($this->_cPtr,$mimeData);
	}

	function PrefetchPublicKey($selector,$domain) {
		return CkDkim_PrefetchPublicKey($this->_cPtr,$selector,$domain);
	}

	function PrefetchPublicKeyAsync($selector,$domain) {
		$r=CkDkim_PrefetchPublicKeyAsync($this->_cPtr,$selector,$domain);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetDkimPrivateKey($privateKey) {
		return CkDkim_SetDkimPrivateKey($this->_cPtr,$privateKey);
	}

	function SetDomainKeyPrivateKey($privateKey) {
		return CkDkim_SetDomainKeyPrivateKey($this->_cPtr,$privateKey);
	}
}

class CkDns {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkDns') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkDns();
	}

	function get_Utf8() {
		return CkDns_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkDns_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkDns_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_DebugLogFilePath($str) {
		CkDns_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkDns_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkDns_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkDns_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkDns_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkDns_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkDns_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkDns_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkDns_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkDns_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkDns_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkDns_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkDns_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_MaxWaitMs() {
		return CkDns_get_MaxWaitMs($this->_cPtr);
	}

	function put_MaxWaitMs($newVal) {
		CkDns_put_MaxWaitMs($this->_cPtr,$newVal);
	}

	function get_NumNameservers() {
		return CkDns_get_NumNameservers($this->_cPtr);
	}

	function get_TlsPref() {
		return CkDns_get_TlsPref($this->_cPtr);
	}

	function put_TlsPref($newVal) {
		CkDns_put_TlsPref($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkDns_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkDns_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkDns_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkDns_version($this->_cPtr);
	}

	function AddDefaultNameservers() {
		CkDns_AddDefaultNameservers($this->_cPtr);
	}

	function AddNameserver($ipAddr,$supportsTls) {
		CkDns_AddNameserver($this->_cPtr,$ipAddr,$supportsTls);
	}

	function getNameserver($index) {
		return CkDns_getNameserver($this->_cPtr,$index);
	}

	function nameserver($index) {
		return CkDns_nameserver($this->_cPtr,$index);
	}

	function Query($recordType,$domain,$answer) {
		return CkDns_Query($this->_cPtr,$recordType,$domain,$answer);
	}

	function QueryAsync($recordType,$domain,$answer) {
		$r=CkDns_QueryAsync($this->_cPtr,$recordType,$domain,$answer);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RemoveAllNameservers() {
		CkDns_RemoveAllNameservers($this->_cPtr);
	}

	function RemoveNameserver($ipAddr) {
		CkDns_RemoveNameserver($this->_cPtr,$ipAddr);
	}
}

class CkDsa {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkDsa') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkDsa();
	}

	function get_Utf8() {
		return CkDsa_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkDsa_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkDsa_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkDsa_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkDsa_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_GroupSize() {
		return CkDsa_get_GroupSize($this->_cPtr);
	}

	function put_GroupSize($newVal) {
		CkDsa_put_GroupSize($this->_cPtr,$newVal);
	}

	function get_HexG($str) {
		CkDsa_get_HexG($this->_cPtr,$str);
	}

	function hexG() {
		return CkDsa_hexG($this->_cPtr);
	}

	function get_HexP($str) {
		CkDsa_get_HexP($this->_cPtr,$str);
	}

	function hexP() {
		return CkDsa_hexP($this->_cPtr);
	}

	function get_HexQ($str) {
		CkDsa_get_HexQ($this->_cPtr,$str);
	}

	function hexQ() {
		return CkDsa_hexQ($this->_cPtr);
	}

	function get_HexX($str) {
		CkDsa_get_HexX($this->_cPtr,$str);
	}

	function hexX() {
		return CkDsa_hexX($this->_cPtr);
	}

	function get_HexY($str) {
		CkDsa_get_HexY($this->_cPtr,$str);
	}

	function hexY() {
		return CkDsa_hexY($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkDsa_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkDsa_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkDsa_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkDsa_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkDsa_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkDsa_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkDsa_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkDsa_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkDsa_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkDsa_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkDsa_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkDsa_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkDsa_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkDsa_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkDsa_version($this->_cPtr);
	}

	function FromDer($derData) {
		return CkDsa_FromDer($this->_cPtr,$derData);
	}

	function FromDerBd($bd) {
		return CkDsa_FromDerBd($this->_cPtr,$bd);
	}

	function FromDerFile($path) {
		return CkDsa_FromDerFile($this->_cPtr,$path);
	}

	function FromEncryptedPem($password,$pemData) {
		return CkDsa_FromEncryptedPem($this->_cPtr,$password,$pemData);
	}

	function FromPem($pemData) {
		return CkDsa_FromPem($this->_cPtr,$pemData);
	}

	function FromPublicDer($derData) {
		return CkDsa_FromPublicDer($this->_cPtr,$derData);
	}

	function FromPublicDerBd($bd) {
		return CkDsa_FromPublicDerBd($this->_cPtr,$bd);
	}

	function FromPublicDerFile($path) {
		return CkDsa_FromPublicDerFile($this->_cPtr,$path);
	}

	function FromPublicPem($pemData) {
		return CkDsa_FromPublicPem($this->_cPtr,$pemData);
	}

	function FromXml($xmlKey) {
		return CkDsa_FromXml($this->_cPtr,$xmlKey);
	}

	function GenKey($numBits) {
		return CkDsa_GenKey($this->_cPtr,$numBits);
	}

	function GenKey2($keyLenBits,$modLenBits) {
		return CkDsa_GenKey2($this->_cPtr,$keyLenBits,$modLenBits);
	}

	function GenKeyFromParamsDer($derBytes) {
		return CkDsa_GenKeyFromParamsDer($this->_cPtr,$derBytes);
	}

	function GenKeyFromParamsDerBd($bd) {
		return CkDsa_GenKeyFromParamsDerBd($this->_cPtr,$bd);
	}

	function GenKeyFromParamsDerFile($path) {
		return CkDsa_GenKeyFromParamsDerFile($this->_cPtr,$path);
	}

	function GenKeyFromParamsPem($pem) {
		return CkDsa_GenKeyFromParamsPem($this->_cPtr,$pem);
	}

	function GenKeyFromParamsPemFile($path) {
		return CkDsa_GenKeyFromParamsPemFile($this->_cPtr,$path);
	}

	function GenKeyFromPQG($pHex,$qHex,$gHex) {
		return CkDsa_GenKeyFromPQG($this->_cPtr,$pHex,$qHex,$gHex);
	}

	function getEncodedHash($encoding) {
		return CkDsa_getEncodedHash($this->_cPtr,$encoding);
	}

	function encodedHash($encoding) {
		return CkDsa_encodedHash($this->_cPtr,$encoding);
	}

	function getEncodedSignature($encoding) {
		return CkDsa_getEncodedSignature($this->_cPtr,$encoding);
	}

	function encodedSignature($encoding) {
		return CkDsa_encodedSignature($this->_cPtr,$encoding);
	}

	function loadText($path) {
		return CkDsa_loadText($this->_cPtr,$path);
	}

	function SaveText($strToSave,$path) {
		return CkDsa_SaveText($this->_cPtr,$strToSave,$path);
	}

	function SetEncodedHash($encoding,$encodedHash) {
		return CkDsa_SetEncodedHash($this->_cPtr,$encoding,$encodedHash);
	}

	function SetEncodedSignature($encoding,$encodedSig) {
		return CkDsa_SetEncodedSignature($this->_cPtr,$encoding,$encodedSig);
	}

	function SetEncodedSignatureRS($encoding,$encodedR,$encodedS) {
		return CkDsa_SetEncodedSignatureRS($this->_cPtr,$encoding,$encodedR,$encodedS);
	}

	function SetKeyExplicit($groupSizeInBytes,$pHex,$qHex,$gHex,$xHex) {
		return CkDsa_SetKeyExplicit($this->_cPtr,$groupSizeInBytes,$pHex,$qHex,$gHex,$xHex);
	}

	function SetPubKeyExplicit($groupSizeInBytes,$pHex,$qHex,$gHex,$yHex) {
		return CkDsa_SetPubKeyExplicit($this->_cPtr,$groupSizeInBytes,$pHex,$qHex,$gHex,$yHex);
	}

	function SignHash() {
		return CkDsa_SignHash($this->_cPtr);
	}

	function ToDer($outBytes) {
		return CkDsa_ToDer($this->_cPtr,$outBytes);
	}

	function ToDerBd($bd) {
		return CkDsa_ToDerBd($this->_cPtr,$bd);
	}

	function ToDerFile($path) {
		return CkDsa_ToDerFile($this->_cPtr,$path);
	}

	function toEncryptedPem($password) {
		return CkDsa_toEncryptedPem($this->_cPtr,$password);
	}

	function toPem() {
		return CkDsa_toPem($this->_cPtr);
	}

	function ToPublicDer($outBytes) {
		return CkDsa_ToPublicDer($this->_cPtr,$outBytes);
	}

	function ToPublicDerBd($bd) {
		return CkDsa_ToPublicDerBd($this->_cPtr,$bd);
	}

	function ToPublicDerFile($path) {
		return CkDsa_ToPublicDerFile($this->_cPtr,$path);
	}

	function toPublicPem() {
		return CkDsa_toPublicPem($this->_cPtr);
	}

	function toXml($bPublicOnly) {
		return CkDsa_toXml($this->_cPtr,$bPublicOnly);
	}

	function Verify() {
		return CkDsa_Verify($this->_cPtr);
	}

	function VerifyKey() {
		return CkDsa_VerifyKey($this->_cPtr);
	}
}

class CkEcc {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkEcc') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkEcc();
	}

	function get_Utf8() {
		return CkEcc_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkEcc_put_Utf8($this->_cPtr,$b);
	}

	function get_AsnFormat() {
		return CkEcc_get_AsnFormat($this->_cPtr);
	}

	function put_AsnFormat($newVal) {
		CkEcc_put_AsnFormat($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkEcc_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkEcc_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkEcc_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkEcc_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkEcc_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkEcc_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkEcc_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkEcc_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkEcc_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkEcc_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkEcc_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkEcc_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkEcc_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkEcc_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkEcc_version($this->_cPtr);
	}

	function GenEccKey($curveName,$prng) {
		$r=CkEcc_GenEccKey($this->_cPtr,$curveName,$prng);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPrivateKey($r);
		}
		return $r;
	}

	function GenEccKey2($curveName,$encodedK,$encoding) {
		$r=CkEcc_GenEccKey2($this->_cPtr,$curveName,$encodedK,$encoding);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPrivateKey($r);
		}
		return $r;
	}

	function GenKey($curveName,$prng,$privKey) {
		return CkEcc_GenKey($this->_cPtr,$curveName,$prng,$privKey);
	}

	function GenKey2($curveName,$encodedK,$encoding,$privKey) {
		return CkEcc_GenKey2($this->_cPtr,$curveName,$encodedK,$encoding,$privKey);
	}

	function sharedSecretENC($privKey,$pubKey,$encoding) {
		return CkEcc_sharedSecretENC($this->_cPtr,$privKey,$pubKey,$encoding);
	}

	function signBd($bdData,$hashAlg,$encoding,$privKey,$prng) {
		return CkEcc_signBd($this->_cPtr,$bdData,$hashAlg,$encoding,$privKey,$prng);
	}

	function signBdUsingCert($bdData,$hashAlg,$encoding,$cert) {
		return CkEcc_signBdUsingCert($this->_cPtr,$bdData,$hashAlg,$encoding,$cert);
	}

	function signHashENC($encodedHash,$encoding,$privkey,$prng) {
		return CkEcc_signHashENC($this->_cPtr,$encodedHash,$encoding,$privkey,$prng);
	}

	function signHashUsingCert($encodedHash,$encoding,$cert) {
		return CkEcc_signHashUsingCert($this->_cPtr,$encodedHash,$encoding,$cert);
	}

	function VerifyBd($bdData,$hashAlg,$encodedSig,$encoding,$pubkey) {
		return CkEcc_VerifyBd($this->_cPtr,$bdData,$hashAlg,$encodedSig,$encoding,$pubkey);
	}

	function VerifyHashENC($encodedHash,$encodedSig,$encoding,$pubkey) {
		return CkEcc_VerifyHashENC($this->_cPtr,$encodedHash,$encodedSig,$encoding,$pubkey);
	}
}

class CkEdDSA {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkEdDSA') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkEdDSA();
	}

	function get_Utf8() {
		return CkEdDSA_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkEdDSA_put_Utf8($this->_cPtr,$b);
	}

	function get_Algorithm($str) {
		CkEdDSA_get_Algorithm($this->_cPtr,$str);
	}

	function algorithm() {
		return CkEdDSA_algorithm($this->_cPtr);
	}

	function put_Algorithm($newVal) {
		CkEdDSA_put_Algorithm($this->_cPtr,$newVal);
	}

	function get_Context($str) {
		CkEdDSA_get_Context($this->_cPtr,$str);
	}

	function context() {
		return CkEdDSA_context($this->_cPtr);
	}

	function put_Context($newVal) {
		CkEdDSA_put_Context($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkEdDSA_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkEdDSA_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkEdDSA_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkEdDSA_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkEdDSA_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkEdDSA_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkEdDSA_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkEdDSA_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkEdDSA_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkEdDSA_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkEdDSA_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkEdDSA_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkEdDSA_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkEdDSA_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkEdDSA_version($this->_cPtr);
	}

	function GenEd25519Key($prng,$privKey) {
		return CkEdDSA_GenEd25519Key($this->_cPtr,$prng,$privKey);
	}

	function sharedSecretENC($privkey,$pubkey,$encoding) {
		return CkEdDSA_sharedSecretENC($this->_cPtr,$privkey,$pubkey,$encoding);
	}

	function signBdENC($bd,$encoding,$privkey) {
		return CkEdDSA_signBdENC($this->_cPtr,$bd,$encoding,$privkey);
	}

	function VerifyBdENC($bd,$encodedSig,$enocding,$pubkey) {
		return CkEdDSA_VerifyBdENC($this->_cPtr,$bd,$encodedSig,$enocding,$pubkey);
	}
}

class CkEmail {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkEmail') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkEmail();
	}

	function get_Utf8() {
		return CkEmail_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkEmail_put_Utf8($this->_cPtr,$b);
	}

	function get_Body($str) {
		CkEmail_get_Body($this->_cPtr,$str);
	}

	function body() {
		return CkEmail_body($this->_cPtr);
	}

	function put_Body($newVal) {
		CkEmail_put_Body($this->_cPtr,$newVal);
	}

	function get_BounceAddress($str) {
		CkEmail_get_BounceAddress($this->_cPtr,$str);
	}

	function bounceAddress() {
		return CkEmail_bounceAddress($this->_cPtr);
	}

	function put_BounceAddress($newVal) {
		CkEmail_put_BounceAddress($this->_cPtr,$newVal);
	}

	function get_Charset($str) {
		CkEmail_get_Charset($this->_cPtr,$str);
	}

	function charset() {
		return CkEmail_charset($this->_cPtr);
	}

	function put_Charset($newVal) {
		CkEmail_put_Charset($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkEmail_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkEmail_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkEmail_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Decrypted() {
		return CkEmail_get_Decrypted($this->_cPtr);
	}

	function get_EmailDateStr($str) {
		CkEmail_get_EmailDateStr($this->_cPtr,$str);
	}

	function emailDateStr() {
		return CkEmail_emailDateStr($this->_cPtr);
	}

	function put_EmailDateStr($newVal) {
		CkEmail_put_EmailDateStr($this->_cPtr,$newVal);
	}

	function get_EncryptedBy($str) {
		CkEmail_get_EncryptedBy($this->_cPtr,$str);
	}

	function encryptedBy() {
		return CkEmail_encryptedBy($this->_cPtr);
	}

	function get_FileDistList($str) {
		CkEmail_get_FileDistList($this->_cPtr,$str);
	}

	function fileDistList() {
		return CkEmail_fileDistList($this->_cPtr);
	}

	function put_FileDistList($newVal) {
		CkEmail_put_FileDistList($this->_cPtr,$newVal);
	}

	function get_From($str) {
		CkEmail_get_From($this->_cPtr,$str);
	}

	function ck_from() {
		return CkEmail_ck_from($this->_cPtr);
	}

	function put_From($newVal) {
		CkEmail_put_From($this->_cPtr,$newVal);
	}

	function get_FromAddress($str) {
		CkEmail_get_FromAddress($this->_cPtr,$str);
	}

	function fromAddress() {
		return CkEmail_fromAddress($this->_cPtr);
	}

	function put_FromAddress($newVal) {
		CkEmail_put_FromAddress($this->_cPtr,$newVal);
	}

	function get_FromName($str) {
		CkEmail_get_FromName($this->_cPtr,$str);
	}

	function fromName() {
		return CkEmail_fromName($this->_cPtr);
	}

	function put_FromName($newVal) {
		CkEmail_put_FromName($this->_cPtr,$newVal);
	}

	function get_Header($str) {
		CkEmail_get_Header($this->_cPtr,$str);
	}

	function header() {
		return CkEmail_header($this->_cPtr);
	}

	function get_Language($str) {
		CkEmail_get_Language($this->_cPtr,$str);
	}

	function language() {
		return CkEmail_language($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkEmail_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkEmail_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkEmail_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkEmail_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkEmail_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkEmail_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkEmail_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkEmail_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LocalDateStr($str) {
		CkEmail_get_LocalDateStr($this->_cPtr,$str);
	}

	function localDateStr() {
		return CkEmail_localDateStr($this->_cPtr);
	}

	function put_LocalDateStr($newVal) {
		CkEmail_put_LocalDateStr($this->_cPtr,$newVal);
	}

	function get_Mailer($str) {
		CkEmail_get_Mailer($this->_cPtr,$str);
	}

	function mailer() {
		return CkEmail_mailer($this->_cPtr);
	}

	function put_Mailer($newVal) {
		CkEmail_put_Mailer($this->_cPtr,$newVal);
	}

	function get_NumAlternatives() {
		return CkEmail_get_NumAlternatives($this->_cPtr);
	}

	function get_NumAttachedMessages() {
		return CkEmail_get_NumAttachedMessages($this->_cPtr);
	}

	function get_NumAttachments() {
		return CkEmail_get_NumAttachments($this->_cPtr);
	}

	function get_NumBcc() {
		return CkEmail_get_NumBcc($this->_cPtr);
	}

	function get_NumCC() {
		return CkEmail_get_NumCC($this->_cPtr);
	}

	function get_NumDaysOld() {
		return CkEmail_get_NumDaysOld($this->_cPtr);
	}

	function get_NumDigests() {
		return CkEmail_get_NumDigests($this->_cPtr);
	}

	function get_NumHeaderFields() {
		return CkEmail_get_NumHeaderFields($this->_cPtr);
	}

	function get_NumRelatedItems() {
		return CkEmail_get_NumRelatedItems($this->_cPtr);
	}

	function get_NumReplacePatterns() {
		return CkEmail_get_NumReplacePatterns($this->_cPtr);
	}

	function get_NumReports() {
		return CkEmail_get_NumReports($this->_cPtr);
	}

	function get_NumTo() {
		return CkEmail_get_NumTo($this->_cPtr);
	}

	function get_OaepHash($str) {
		CkEmail_get_OaepHash($this->_cPtr,$str);
	}

	function oaepHash() {
		return CkEmail_oaepHash($this->_cPtr);
	}

	function put_OaepHash($newVal) {
		CkEmail_put_OaepHash($this->_cPtr,$newVal);
	}

	function get_OaepMgfHash($str) {
		CkEmail_get_OaepMgfHash($this->_cPtr,$str);
	}

	function oaepMgfHash() {
		return CkEmail_oaepMgfHash($this->_cPtr);
	}

	function put_OaepMgfHash($newVal) {
		CkEmail_put_OaepMgfHash($this->_cPtr,$newVal);
	}

	function get_OaepPadding() {
		return CkEmail_get_OaepPadding($this->_cPtr);
	}

	function put_OaepPadding($newVal) {
		CkEmail_put_OaepPadding($this->_cPtr,$newVal);
	}

	function get_OverwriteExisting() {
		return CkEmail_get_OverwriteExisting($this->_cPtr);
	}

	function put_OverwriteExisting($newVal) {
		CkEmail_put_OverwriteExisting($this->_cPtr,$newVal);
	}

	function get_Pkcs7CryptAlg($str) {
		CkEmail_get_Pkcs7CryptAlg($this->_cPtr,$str);
	}

	function pkcs7CryptAlg() {
		return CkEmail_pkcs7CryptAlg($this->_cPtr);
	}

	function put_Pkcs7CryptAlg($newVal) {
		CkEmail_put_Pkcs7CryptAlg($this->_cPtr,$newVal);
	}

	function get_Pkcs7KeyLength() {
		return CkEmail_get_Pkcs7KeyLength($this->_cPtr);
	}

	function put_Pkcs7KeyLength($newVal) {
		CkEmail_put_Pkcs7KeyLength($this->_cPtr,$newVal);
	}

	function get_PreferredCharset($str) {
		CkEmail_get_PreferredCharset($this->_cPtr,$str);
	}

	function preferredCharset() {
		return CkEmail_preferredCharset($this->_cPtr);
	}

	function put_PreferredCharset($newVal) {
		CkEmail_put_PreferredCharset($this->_cPtr,$newVal);
	}

	function get_PrependHeaders() {
		return CkEmail_get_PrependHeaders($this->_cPtr);
	}

	function put_PrependHeaders($newVal) {
		CkEmail_put_PrependHeaders($this->_cPtr,$newVal);
	}

	function get_ReceivedEncrypted() {
		return CkEmail_get_ReceivedEncrypted($this->_cPtr);
	}

	function get_ReceivedSigned() {
		return CkEmail_get_ReceivedSigned($this->_cPtr);
	}

	function get_ReplyTo($str) {
		CkEmail_get_ReplyTo($this->_cPtr,$str);
	}

	function replyTo() {
		return CkEmail_replyTo($this->_cPtr);
	}

	function put_ReplyTo($newVal) {
		CkEmail_put_ReplyTo($this->_cPtr,$newVal);
	}

	function get_ReturnReceipt() {
		return CkEmail_get_ReturnReceipt($this->_cPtr);
	}

	function put_ReturnReceipt($newVal) {
		CkEmail_put_ReturnReceipt($this->_cPtr,$newVal);
	}

	function get_SendEncrypted() {
		return CkEmail_get_SendEncrypted($this->_cPtr);
	}

	function put_SendEncrypted($newVal) {
		CkEmail_put_SendEncrypted($this->_cPtr,$newVal);
	}

	function get_SendSigned() {
		return CkEmail_get_SendSigned($this->_cPtr);
	}

	function put_SendSigned($newVal) {
		CkEmail_put_SendSigned($this->_cPtr,$newVal);
	}

	function get_SignaturesValid() {
		return CkEmail_get_SignaturesValid($this->_cPtr);
	}

	function get_SignedBy($str) {
		CkEmail_get_SignedBy($this->_cPtr,$str);
	}

	function signedBy() {
		return CkEmail_signedBy($this->_cPtr);
	}

	function get_SigningAlg($str) {
		CkEmail_get_SigningAlg($this->_cPtr,$str);
	}

	function signingAlg() {
		return CkEmail_signingAlg($this->_cPtr);
	}

	function put_SigningAlg($newVal) {
		CkEmail_put_SigningAlg($this->_cPtr,$newVal);
	}

	function get_SigningHashAlg($str) {
		CkEmail_get_SigningHashAlg($this->_cPtr,$str);
	}

	function signingHashAlg() {
		return CkEmail_signingHashAlg($this->_cPtr);
	}

	function put_SigningHashAlg($newVal) {
		CkEmail_put_SigningHashAlg($this->_cPtr,$newVal);
	}

	function get_Size() {
		return CkEmail_get_Size($this->_cPtr);
	}

	function get_Subject($str) {
		CkEmail_get_Subject($this->_cPtr,$str);
	}

	function subject() {
		return CkEmail_subject($this->_cPtr);
	}

	function put_Subject($newVal) {
		CkEmail_put_Subject($this->_cPtr,$newVal);
	}

	function get_Uidl($str) {
		CkEmail_get_Uidl($this->_cPtr,$str);
	}

	function uidl() {
		return CkEmail_uidl($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkEmail_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkEmail_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkEmail_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UnpackUseRelPaths() {
		return CkEmail_get_UnpackUseRelPaths($this->_cPtr);
	}

	function put_UnpackUseRelPaths($newVal) {
		CkEmail_put_UnpackUseRelPaths($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkEmail_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkEmail_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkEmail_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkEmail_version($this->_cPtr);
	}

	function AddAttachmentBd($filename,$binData,$contentType) {
		return CkEmail_AddAttachmentBd($this->_cPtr,$filename,$binData,$contentType);
	}

	function AddAttachmentHeader($index,$fieldName,$fieldValue) {
		CkEmail_AddAttachmentHeader($this->_cPtr,$index,$fieldName,$fieldValue);
	}

	function AddBcc($friendlyName,$emailAddress) {
		return CkEmail_AddBcc($this->_cPtr,$friendlyName,$emailAddress);
	}

	function AddCC($friendlyName,$emailAddress) {
		return CkEmail_AddCC($this->_cPtr,$friendlyName,$emailAddress);
	}

	function AddDataAttachment($fileName,$content) {
		return CkEmail_AddDataAttachment($this->_cPtr,$fileName,$content);
	}

	function AddDataAttachment2($fileName,$content,$contentType) {
		return CkEmail_AddDataAttachment2($this->_cPtr,$fileName,$content,$contentType);
	}

	function AddEncryptCert($cert) {
		return CkEmail_AddEncryptCert($this->_cPtr,$cert);
	}

	function addFileAttachment($path) {
		return CkEmail_addFileAttachment($this->_cPtr,$path);
	}

	function AddFileAttachment2($path,$contentType) {
		return CkEmail_AddFileAttachment2($this->_cPtr,$path,$contentType);
	}

	function AddHeaderField($fieldName,$fieldValue) {
		CkEmail_AddHeaderField($this->_cPtr,$fieldName,$fieldValue);
	}

	function AddHeaderField2($fieldName,$fieldValue) {
		CkEmail_AddHeaderField2($this->_cPtr,$fieldName,$fieldValue);
	}

	function AddHtmlAlternativeBody($body) {
		return CkEmail_AddHtmlAlternativeBody($this->_cPtr,$body);
	}

	function AddiCalendarAlternativeBody($icalContent,$methodName) {
		return CkEmail_AddiCalendarAlternativeBody($this->_cPtr,$icalContent,$methodName);
	}

	function AddMultipleBcc($commaSeparatedAddresses) {
		return CkEmail_AddMultipleBcc($this->_cPtr,$commaSeparatedAddresses);
	}

	function AddMultipleCC($commaSeparatedAddresses) {
		return CkEmail_AddMultipleCC($this->_cPtr,$commaSeparatedAddresses);
	}

	function AddMultipleTo($commaSeparatedAddresses) {
		return CkEmail_AddMultipleTo($this->_cPtr,$commaSeparatedAddresses);
	}

	function AddPfxSourceBd($bd,$password) {
		return CkEmail_AddPfxSourceBd($this->_cPtr,$bd,$password);
	}

	function AddPfxSourceData($pfxBytes,$pfxPassword) {
		return CkEmail_AddPfxSourceData($this->_cPtr,$pfxBytes,$pfxPassword);
	}

	function AddPfxSourceFile($pfxFilePath,$pfxPassword) {
		return CkEmail_AddPfxSourceFile($this->_cPtr,$pfxFilePath,$pfxPassword);
	}

	function AddPlainTextAlternativeBody($body) {
		return CkEmail_AddPlainTextAlternativeBody($this->_cPtr,$body);
	}

	function addRelatedBd($filename,$binData) {
		return CkEmail_addRelatedBd($this->_cPtr,$filename,$binData);
	}

	function AddRelatedBd2($binData,$fileNameInHtml) {
		return CkEmail_AddRelatedBd2($this->_cPtr,$binData,$fileNameInHtml);
	}

	function addRelatedData($fileName,$inData) {
		return CkEmail_addRelatedData($this->_cPtr,$fileName,$inData);
	}

	function AddRelatedData2($inData,$fileNameInHtml) {
		CkEmail_AddRelatedData2($this->_cPtr,$inData,$fileNameInHtml);
	}

	function addRelatedFile($path) {
		return CkEmail_addRelatedFile($this->_cPtr,$path);
	}

	function AddRelatedFile2($filenameOnDisk,$filenameInHtml) {
		return CkEmail_AddRelatedFile2($this->_cPtr,$filenameOnDisk,$filenameInHtml);
	}

	function AddRelatedHeader($index,$fieldName,$fieldValue) {
		CkEmail_AddRelatedHeader($this->_cPtr,$index,$fieldName,$fieldValue);
	}

	function addRelatedString($nameInHtml,$str,$charset) {
		return CkEmail_addRelatedString($this->_cPtr,$nameInHtml,$str,$charset);
	}

	function AddRelatedString2($fileNameInHtml,$content,$charset) {
		CkEmail_AddRelatedString2($this->_cPtr,$fileNameInHtml,$content,$charset);
	}

	function AddStringAttachment($path,$content) {
		return CkEmail_AddStringAttachment($this->_cPtr,$path,$content);
	}

	function AddStringAttachment2($path,$content,$charset) {
		return CkEmail_AddStringAttachment2($this->_cPtr,$path,$content,$charset);
	}

	function AddTo($friendlyName,$emailAddress) {
		return CkEmail_AddTo($this->_cPtr,$friendlyName,$emailAddress);
	}

	function AesDecrypt($password) {
		return CkEmail_AesDecrypt($this->_cPtr,$password);
	}

	function AesEncrypt($password) {
		return CkEmail_AesEncrypt($this->_cPtr,$password);
	}

	function AppendToBody($str) {
		CkEmail_AppendToBody($this->_cPtr,$str);
	}

	function ApplyFixups($fixups) {
		return CkEmail_ApplyFixups($this->_cPtr,$fixups);
	}

	function AspUnpack($prefix,$saveDir,$urlPath,$cleanFiles) {
		return CkEmail_AspUnpack($this->_cPtr,$prefix,$saveDir,$urlPath,$cleanFiles);
	}

	function AspUnpack2($prefix,$saveDir,$urlPath,$cleanFiles,$outHtml) {
		return CkEmail_AspUnpack2($this->_cPtr,$prefix,$saveDir,$urlPath,$cleanFiles,$outHtml);
	}

	function AttachEmail($email) {
		return CkEmail_AttachEmail($this->_cPtr,$email);
	}

	function AttachMessage($mimeBytes) {
		return CkEmail_AttachMessage($this->_cPtr,$mimeBytes);
	}

	function bEncodeBytes($inData,$charset) {
		return CkEmail_bEncodeBytes($this->_cPtr,$inData,$charset);
	}

	function bEncodeString($str,$charset) {
		return CkEmail_bEncodeString($this->_cPtr,$str,$charset);
	}

	function Clear() {
		CkEmail_Clear($this->_cPtr);
	}

	function ClearBcc() {
		CkEmail_ClearBcc($this->_cPtr);
	}

	function ClearCC() {
		CkEmail_ClearCC($this->_cPtr);
	}

	function ClearEncryptCerts() {
		CkEmail_ClearEncryptCerts($this->_cPtr);
	}

	function ClearTo() {
		CkEmail_ClearTo($this->_cPtr);
	}

	function c_Clone() {
		$r=CkEmail_c_Clone($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function computeGlobalKey2($encoding,$bFold) {
		return CkEmail_computeGlobalKey2($this->_cPtr,$encoding,$bFold);
	}

	function ConvertInlineImages() {
		return CkEmail_ConvertInlineImages($this->_cPtr);
	}

	function CreateDsn($humanReadableMessage,$xmlStatusFields,$bHeaderOnly) {
		$r=CkEmail_CreateDsn($this->_cPtr,$humanReadableMessage,$xmlStatusFields,$bHeaderOnly);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function CreateForward() {
		$r=CkEmail_CreateForward($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function CreateMdn($humanReadableMessage,$xmlStatusFields,$bHeaderOnly) {
		$r=CkEmail_CreateMdn($this->_cPtr,$humanReadableMessage,$xmlStatusFields,$bHeaderOnly);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function CreateReply() {
		$r=CkEmail_CreateReply($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function createTempMht($inFilename) {
		return CkEmail_createTempMht($this->_cPtr,$inFilename);
	}

	function DropAttachments() {
		CkEmail_DropAttachments($this->_cPtr);
	}

	function DropRelatedItem($index) {
		CkEmail_DropRelatedItem($this->_cPtr,$index);
	}

	function DropRelatedItems() {
		CkEmail_DropRelatedItems($this->_cPtr);
	}

	function DropSingleAttachment($index) {
		return CkEmail_DropSingleAttachment($this->_cPtr,$index);
	}

	function FindIssuer($cert) {
		$r=CkEmail_FindIssuer($this->_cPtr,$cert);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function generateFilename() {
		return CkEmail_generateFilename($this->_cPtr);
	}

	function getAlternativeBody($index) {
		return CkEmail_getAlternativeBody($this->_cPtr,$index);
	}

	function alternativeBody($index) {
		return CkEmail_alternativeBody($this->_cPtr,$index);
	}

	function GetAlternativeBodyBd($index,$binData) {
		return CkEmail_GetAlternativeBodyBd($this->_cPtr,$index,$binData);
	}

	function getAlternativeBodyByContentType($contentType) {
		return CkEmail_getAlternativeBodyByContentType($this->_cPtr,$contentType);
	}

	function alternativeBodyByContentType($contentType) {
		return CkEmail_alternativeBodyByContentType($this->_cPtr,$contentType);
	}

	function getAlternativeContentType($index) {
		return CkEmail_getAlternativeContentType($this->_cPtr,$index);
	}

	function alternativeContentType($index) {
		return CkEmail_alternativeContentType($this->_cPtr,$index);
	}

	function getAltHeaderField($index,$fieldName) {
		return CkEmail_getAltHeaderField($this->_cPtr,$index,$fieldName);
	}

	function altHeaderField($index,$fieldName) {
		return CkEmail_altHeaderField($this->_cPtr,$index,$fieldName);
	}

	function GetAttachedEmail($index,$email) {
		return CkEmail_GetAttachedEmail($this->_cPtr,$index,$email);
	}

	function GetAttachedMessage($index) {
		$r=CkEmail_GetAttachedMessage($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function getAttachedMessageAttr($index,$fieldName,$attrName) {
		return CkEmail_getAttachedMessageAttr($this->_cPtr,$index,$fieldName,$attrName);
	}

	function attachedMessageAttr($index,$fieldName,$attrName) {
		return CkEmail_attachedMessageAttr($this->_cPtr,$index,$fieldName,$attrName);
	}

	function getAttachedMessageFilename($index) {
		return CkEmail_getAttachedMessageFilename($this->_cPtr,$index);
	}

	function attachedMessageFilename($index) {
		return CkEmail_attachedMessageFilename($this->_cPtr,$index);
	}

	function getAttachmentAttr($index,$fieldName,$attrName) {
		return CkEmail_getAttachmentAttr($this->_cPtr,$index,$fieldName,$attrName);
	}

	function attachmentAttr($index,$fieldName,$attrName) {
		return CkEmail_attachmentAttr($this->_cPtr,$index,$fieldName,$attrName);
	}

	function GetAttachmentBd($index,$binData) {
		return CkEmail_GetAttachmentBd($this->_cPtr,$index,$binData);
	}

	function getAttachmentContentID($index) {
		return CkEmail_getAttachmentContentID($this->_cPtr,$index);
	}

	function attachmentContentID($index) {
		return CkEmail_attachmentContentID($this->_cPtr,$index);
	}

	function getAttachmentContentType($index) {
		return CkEmail_getAttachmentContentType($this->_cPtr,$index);
	}

	function attachmentContentType($index) {
		return CkEmail_attachmentContentType($this->_cPtr,$index);
	}

	function GetAttachmentData($index,$outData) {
		return CkEmail_GetAttachmentData($this->_cPtr,$index,$outData);
	}

	function getAttachmentFilename($index) {
		return CkEmail_getAttachmentFilename($this->_cPtr,$index);
	}

	function attachmentFilename($index) {
		return CkEmail_attachmentFilename($this->_cPtr,$index);
	}

	function getAttachmentHeader($attachIndex,$fieldName) {
		return CkEmail_getAttachmentHeader($this->_cPtr,$attachIndex,$fieldName);
	}

	function attachmentHeader($attachIndex,$fieldName) {
		return CkEmail_attachmentHeader($this->_cPtr,$attachIndex,$fieldName);
	}

	function GetAttachmentSize($index) {
		return CkEmail_GetAttachmentSize($this->_cPtr,$index);
	}

	function getAttachmentString($index,$charset) {
		return CkEmail_getAttachmentString($this->_cPtr,$index,$charset);
	}

	function attachmentString($index,$charset) {
		return CkEmail_attachmentString($this->_cPtr,$index,$charset);
	}

	function getAttachmentStringCrLf($index,$charset) {
		return CkEmail_getAttachmentStringCrLf($this->_cPtr,$index,$charset);
	}

	function attachmentStringCrLf($index,$charset) {
		return CkEmail_attachmentStringCrLf($this->_cPtr,$index,$charset);
	}

	function getBcc($index) {
		return CkEmail_getBcc($this->_cPtr,$index);
	}

	function bcc($index) {
		return CkEmail_bcc($this->_cPtr,$index);
	}

	function getBccAddr($index) {
		return CkEmail_getBccAddr($this->_cPtr,$index);
	}

	function bccAddr($index) {
		return CkEmail_bccAddr($this->_cPtr,$index);
	}

	function getBccName($index) {
		return CkEmail_getBccName($this->_cPtr,$index);
	}

	function bccName($index) {
		return CkEmail_bccName($this->_cPtr,$index);
	}

	function getCC($index) {
		return CkEmail_getCC($this->_cPtr,$index);
	}

	function cC($index) {
		return CkEmail_cC($this->_cPtr,$index);
	}

	function getCcAddr($index) {
		return CkEmail_getCcAddr($this->_cPtr,$index);
	}

	function ccAddr($index) {
		return CkEmail_ccAddr($this->_cPtr,$index);
	}

	function getCcName($index) {
		return CkEmail_getCcName($this->_cPtr,$index);
	}

	function ccName($index) {
		return CkEmail_ccName($this->_cPtr,$index);
	}

	function getDeliveryStatusInfo($fieldName) {
		return CkEmail_getDeliveryStatusInfo($this->_cPtr,$fieldName);
	}

	function deliveryStatusInfo($fieldName) {
		return CkEmail_deliveryStatusInfo($this->_cPtr,$fieldName);
	}

	function GetDigest($index) {
		$r=CkEmail_GetDigest($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function GetDigestEmail($index,$email) {
		return CkEmail_GetDigestEmail($this->_cPtr,$index,$email);
	}

	function GetDsnFinalRecipients() {
		$r=CkEmail_GetDsnFinalRecipients($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function GetDsnInfo($json) {
		return CkEmail_GetDsnInfo($this->_cPtr,$json);
	}

	function GetDt() {
		$r=CkEmail_GetDt($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetEncryptCert() {
		$r=CkEmail_GetEncryptCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetEncryptedByCert() {
		$r=CkEmail_GetEncryptedByCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetFileContent($path,$outData) {
		return CkEmail_GetFileContent($this->_cPtr,$path,$outData);
	}

	function getHeaderField($fieldName) {
		return CkEmail_getHeaderField($this->_cPtr,$fieldName);
	}

	function headerField($fieldName) {
		return CkEmail_headerField($this->_cPtr,$fieldName);
	}

	function getHeaderFieldName($index) {
		return CkEmail_getHeaderFieldName($this->_cPtr,$index);
	}

	function headerFieldName($index) {
		return CkEmail_headerFieldName($this->_cPtr,$index);
	}

	function getHeaderFieldValue($index) {
		return CkEmail_getHeaderFieldValue($this->_cPtr,$index);
	}

	function headerFieldValue($index) {
		return CkEmail_headerFieldValue($this->_cPtr,$index);
	}

	function getHtmlBody() {
		return CkEmail_getHtmlBody($this->_cPtr);
	}

	function htmlBody() {
		return CkEmail_htmlBody($this->_cPtr);
	}

	function GetHtmlBodySb($inlineImageData,$sb) {
		return CkEmail_GetHtmlBodySb($this->_cPtr,$inlineImageData,$sb);
	}

	function GetImapUid() {
		return CkEmail_GetImapUid($this->_cPtr);
	}

	function GetLinkedDomains() {
		$r=CkEmail_GetLinkedDomains($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function getMime() {
		return CkEmail_getMime($this->_cPtr);
	}

	function mime() {
		return CkEmail_mime($this->_cPtr);
	}

	function GetMimeBd($bindat) {
		return CkEmail_GetMimeBd($this->_cPtr,$bindat);
	}

	function GetMimeBinary($outBytes) {
		return CkEmail_GetMimeBinary($this->_cPtr,$outBytes);
	}

	function GetMimeSb($sb) {
		return CkEmail_GetMimeSb($this->_cPtr,$sb);
	}

	function GetNthBinaryPartOfType($index,$contentType,$inlineOnly,$excludeAttachments,$outBytes) {
		return CkEmail_GetNthBinaryPartOfType($this->_cPtr,$index,$contentType,$inlineOnly,$excludeAttachments,$outBytes);
	}

	function GetNthBinaryPartOfTypeBd($index,$contentType,$inlineOnly,$excludeAttachments,$bd) {
		return CkEmail_GetNthBinaryPartOfTypeBd($this->_cPtr,$index,$contentType,$inlineOnly,$excludeAttachments,$bd);
	}

	function getNthContentType($index,$contentType,$inlineOnly,$excludeAttachments) {
		return CkEmail_getNthContentType($this->_cPtr,$index,$contentType,$inlineOnly,$excludeAttachments);
	}

	function nthContentType($index,$contentType,$inlineOnly,$excludeAttachments) {
		return CkEmail_nthContentType($this->_cPtr,$index,$contentType,$inlineOnly,$excludeAttachments);
	}

	function getNthTextPartOfType($index,$contentType,$inlineOnly,$excludeAttachments) {
		return CkEmail_getNthTextPartOfType($this->_cPtr,$index,$contentType,$inlineOnly,$excludeAttachments);
	}

	function nthTextPartOfType($index,$contentType,$inlineOnly,$excludeAttachments) {
		return CkEmail_nthTextPartOfType($this->_cPtr,$index,$contentType,$inlineOnly,$excludeAttachments);
	}

	function GetNumPartsOfType($contentType,$inlineOnly,$excludeAttachments) {
		return CkEmail_GetNumPartsOfType($this->_cPtr,$contentType,$inlineOnly,$excludeAttachments);
	}

	function getPlainTextBody() {
		return CkEmail_getPlainTextBody($this->_cPtr);
	}

	function plainTextBody() {
		return CkEmail_plainTextBody($this->_cPtr);
	}

	function getRelatedAttr($index,$fieldName,$attrName) {
		return CkEmail_getRelatedAttr($this->_cPtr,$index,$fieldName,$attrName);
	}

	function relatedAttr($index,$fieldName,$attrName) {
		return CkEmail_relatedAttr($this->_cPtr,$index,$fieldName,$attrName);
	}

	function getRelatedContentID($index) {
		return CkEmail_getRelatedContentID($this->_cPtr,$index);
	}

	function relatedContentID($index) {
		return CkEmail_relatedContentID($this->_cPtr,$index);
	}

	function getRelatedContentLocation($index) {
		return CkEmail_getRelatedContentLocation($this->_cPtr,$index);
	}

	function relatedContentLocation($index) {
		return CkEmail_relatedContentLocation($this->_cPtr,$index);
	}

	function getRelatedContentType($index) {
		return CkEmail_getRelatedContentType($this->_cPtr,$index);
	}

	function relatedContentType($index) {
		return CkEmail_relatedContentType($this->_cPtr,$index);
	}

	function GetRelatedData($index,$outBuffer) {
		return CkEmail_GetRelatedData($this->_cPtr,$index,$outBuffer);
	}

	function getRelatedFilename($index) {
		return CkEmail_getRelatedFilename($this->_cPtr,$index);
	}

	function relatedFilename($index) {
		return CkEmail_relatedFilename($this->_cPtr,$index);
	}

	function getRelatedHeader($index,$fieldName) {
		return CkEmail_getRelatedHeader($this->_cPtr,$index,$fieldName);
	}

	function relatedHeader($index,$fieldName) {
		return CkEmail_relatedHeader($this->_cPtr,$index,$fieldName);
	}

	function getRelatedString($index,$charset) {
		return CkEmail_getRelatedString($this->_cPtr,$index,$charset);
	}

	function relatedString($index,$charset) {
		return CkEmail_relatedString($this->_cPtr,$index,$charset);
	}

	function getRelatedStringCrLf($index,$charset) {
		return CkEmail_getRelatedStringCrLf($this->_cPtr,$index,$charset);
	}

	function relatedStringCrLf($index,$charset) {
		return CkEmail_relatedStringCrLf($this->_cPtr,$index,$charset);
	}

	function getReplacePattern($index) {
		return CkEmail_getReplacePattern($this->_cPtr,$index);
	}

	function replacePattern($index) {
		return CkEmail_replacePattern($this->_cPtr,$index);
	}

	function getReplaceString($index) {
		return CkEmail_getReplaceString($this->_cPtr,$index);
	}

	function replaceString($index) {
		return CkEmail_replaceString($this->_cPtr,$index);
	}

	function getReplaceString2($pattern) {
		return CkEmail_getReplaceString2($this->_cPtr,$pattern);
	}

	function replaceString2($pattern) {
		return CkEmail_replaceString2($this->_cPtr,$pattern);
	}

	function getReport($index) {
		return CkEmail_getReport($this->_cPtr,$index);
	}

	function report($index) {
		return CkEmail_report($this->_cPtr,$index);
	}

	function GetSignedByCert() {
		$r=CkEmail_GetSignedByCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetSignedByCertChain() {
		$r=CkEmail_GetSignedByCertChain($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCertChain($r);
		}
		return $r;
	}

	function GetSigningCert() {
		$r=CkEmail_GetSigningCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function getTo($index) {
		return CkEmail_getTo($this->_cPtr,$index);
	}

	function to($index) {
		return CkEmail_to($this->_cPtr,$index);
	}

	function getToAddr($index) {
		return CkEmail_getToAddr($this->_cPtr,$index);
	}

	function toAddr($index) {
		return CkEmail_toAddr($this->_cPtr,$index);
	}

	function getToName($index) {
		return CkEmail_getToName($this->_cPtr,$index);
	}

	function toName($index) {
		return CkEmail_toName($this->_cPtr,$index);
	}

	function getXml() {
		return CkEmail_getXml($this->_cPtr);
	}

	function xml() {
		return CkEmail_xml($this->_cPtr);
	}

	function HasHeaderMatching($fieldName,$valuePattern,$caseSensitive) {
		return CkEmail_HasHeaderMatching($this->_cPtr,$fieldName,$valuePattern,$caseSensitive);
	}

	function HasHtmlBody() {
		return CkEmail_HasHtmlBody($this->_cPtr);
	}

	function HasPlainTextBody() {
		return CkEmail_HasPlainTextBody($this->_cPtr);
	}

	function IsMultipartReport() {
		return CkEmail_IsMultipartReport($this->_cPtr);
	}

	function LastDecryptCert($cert) {
		return CkEmail_LastDecryptCert($this->_cPtr,$cert);
	}

	function LastSignerCert($index,$cert) {
		return CkEmail_LastSignerCert($this->_cPtr,$index,$cert);
	}

	function LinkedDomains($domains) {
		return CkEmail_LinkedDomains($this->_cPtr,$domains);
	}

	function LoadEml($mimePath) {
		return CkEmail_LoadEml($this->_cPtr,$mimePath);
	}

	function LoadTaskResult($task) {
		return CkEmail_LoadTaskResult($this->_cPtr,$task);
	}

	function LoadXml($xmlPath) {
		return CkEmail_LoadXml($this->_cPtr,$xmlPath);
	}

	function LoadXmlString($xmlStr) {
		return CkEmail_LoadXmlString($this->_cPtr,$xmlStr);
	}

	function MakeCopy($destEmail) {
		return CkEmail_MakeCopy($this->_cPtr,$destEmail);
	}

	function qEncodeBytes($inData,$charset) {
		return CkEmail_qEncodeBytes($this->_cPtr,$inData,$charset);
	}

	function qEncodeString($str,$charset) {
		return CkEmail_qEncodeString($this->_cPtr,$str,$charset);
	}

	function RemoveAttachedMessage($idx) {
		CkEmail_RemoveAttachedMessage($this->_cPtr,$idx);
	}

	function RemoveAttachedMessages() {
		CkEmail_RemoveAttachedMessages($this->_cPtr);
	}

	function RemoveAttachmentPaths() {
		CkEmail_RemoveAttachmentPaths($this->_cPtr);
	}

	function RemoveHeaderField($fieldName) {
		CkEmail_RemoveHeaderField($this->_cPtr,$fieldName);
	}

	function RemoveHtmlAlternative() {
		CkEmail_RemoveHtmlAlternative($this->_cPtr);
	}

	function RemovePlainTextAlternative() {
		CkEmail_RemovePlainTextAlternative($this->_cPtr);
	}

	function SaveAllAttachments($dirPath) {
		return CkEmail_SaveAllAttachments($this->_cPtr,$dirPath);
	}

	function SaveAttachedFile($index,$dirPath) {
		return CkEmail_SaveAttachedFile($this->_cPtr,$index,$dirPath);
	}

	function SaveEml($emlFilePath) {
		return CkEmail_SaveEml($this->_cPtr,$emlFilePath);
	}

	function SaveRelatedItem($index,$dirPath) {
		return CkEmail_SaveRelatedItem($this->_cPtr,$index,$dirPath);
	}

	function SaveXml($path) {
		return CkEmail_SaveXml($this->_cPtr,$path);
	}

	function SetAttachmentCharset($index,$charset) {
		return CkEmail_SetAttachmentCharset($this->_cPtr,$index,$charset);
	}

	function SetAttachmentDisposition($index,$disposition) {
		return CkEmail_SetAttachmentDisposition($this->_cPtr,$index,$disposition);
	}

	function SetAttachmentFilename($index,$filename) {
		return CkEmail_SetAttachmentFilename($this->_cPtr,$index,$filename);
	}

	function SetBinaryBody($byteData,$contentType,$disposition,$filename) {
		return CkEmail_SetBinaryBody($this->_cPtr,$byteData,$contentType,$disposition,$filename);
	}

	function SetBodyBd($bd,$contentType,$disposition,$filename) {
		return CkEmail_SetBodyBd($this->_cPtr,$bd,$contentType,$disposition,$filename);
	}

	function SetDecryptCert($cert) {
		return CkEmail_SetDecryptCert($this->_cPtr,$cert);
	}

	function SetDecryptCert2($cert,$key) {
		return CkEmail_SetDecryptCert2($this->_cPtr,$cert,$key);
	}

	function SetDt($dt) {
		return CkEmail_SetDt($this->_cPtr,$dt);
	}

	function SetEdifactBody($message,$name,$filename,$charset) {
		CkEmail_SetEdifactBody($this->_cPtr,$message,$name,$filename,$charset);
	}

	function SetEncryptCert($cert) {
		return CkEmail_SetEncryptCert($this->_cPtr,$cert);
	}

	function SetFromMimeBd($bindat) {
		return CkEmail_SetFromMimeBd($this->_cPtr,$bindat);
	}

	function SetFromMimeBytes($mimeBytes) {
		return CkEmail_SetFromMimeBytes($this->_cPtr,$mimeBytes);
	}

	function SetFromMimeBytes2($mimeBytes,$charset) {
		return CkEmail_SetFromMimeBytes2($this->_cPtr,$mimeBytes,$charset);
	}

	function SetFromMimeSb($sb) {
		return CkEmail_SetFromMimeSb($this->_cPtr,$sb);
	}

	function SetFromMimeText($mimeText) {
		return CkEmail_SetFromMimeText($this->_cPtr,$mimeText);
	}

	function SetFromXmlText($xmlStr) {
		return CkEmail_SetFromXmlText($this->_cPtr,$xmlStr);
	}

	function SetHtmlBody($html) {
		CkEmail_SetHtmlBody($this->_cPtr,$html);
	}

	function SetMbHtmlBody($charset,$inData) {
		return CkEmail_SetMbHtmlBody($this->_cPtr,$charset,$inData);
	}

	function SetMbPlainTextBody($charset,$inData) {
		return CkEmail_SetMbPlainTextBody($this->_cPtr,$charset,$inData);
	}

	function SetRelatedFilename($index,$path) {
		return CkEmail_SetRelatedFilename($this->_cPtr,$index,$path);
	}

	function SetReplacePattern($pattern,$replaceString) {
		return CkEmail_SetReplacePattern($this->_cPtr,$pattern,$replaceString);
	}

	function SetSigningCert($cert) {
		return CkEmail_SetSigningCert($this->_cPtr,$cert);
	}

	function SetSigningCert2($cert,$key) {
		return CkEmail_SetSigningCert2($this->_cPtr,$cert,$key);
	}

	function SetTextBody($bodyText,$contentType) {
		CkEmail_SetTextBody($this->_cPtr,$bodyText,$contentType);
	}

	function ToDsn($explanation,$statusFields,$headerOnly,$dsnEmail) {
		return CkEmail_ToDsn($this->_cPtr,$explanation,$statusFields,$headerOnly,$dsnEmail);
	}

	function ToForward($forward) {
		return CkEmail_ToForward($this->_cPtr,$forward);
	}

	function ToMdn($message,$statusFields,$headerOnly,$mdn) {
		return CkEmail_ToMdn($this->_cPtr,$message,$statusFields,$headerOnly,$mdn);
	}

	function ToReply($reply) {
		return CkEmail_ToReply($this->_cPtr,$reply);
	}

	function UidlEquals($e) {
		return CkEmail_UidlEquals($this->_cPtr,$e);
	}

	function UnpackHtml($unpackDir,$htmlFilename,$partsSubdir) {
		return CkEmail_UnpackHtml($this->_cPtr,$unpackDir,$htmlFilename,$partsSubdir);
	}

	function UnSpamify() {
		CkEmail_UnSpamify($this->_cPtr);
	}

	function UnzipAttachments() {
		return CkEmail_UnzipAttachments($this->_cPtr);
	}

	function UseCertVault($vault) {
		return CkEmail_UseCertVault($this->_cPtr,$vault);
	}

	function ZipAttachments($zipFilename) {
		return CkEmail_ZipAttachments($this->_cPtr,$zipFilename);
	}
}

class CkEmailBundle {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkEmailBundle') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkEmailBundle();
	}

	function get_Utf8() {
		return CkEmailBundle_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkEmailBundle_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkEmailBundle_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkEmailBundle_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkEmailBundle_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkEmailBundle_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkEmailBundle_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkEmailBundle_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkEmailBundle_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkEmailBundle_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkEmailBundle_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkEmailBundle_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkEmailBundle_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_MessageCount() {
		return CkEmailBundle_get_MessageCount($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkEmailBundle_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkEmailBundle_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkEmailBundle_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkEmailBundle_version($this->_cPtr);
	}

	function AddEmail($email) {
		return CkEmailBundle_AddEmail($this->_cPtr,$email);
	}

	function Clear() {
		CkEmailBundle_Clear($this->_cPtr);
	}

	function EmailAt($index,$email) {
		return CkEmailBundle_EmailAt($this->_cPtr,$index,$email);
	}

	function FindByHeader($headerFieldName,$headerFieldValue) {
		$r=CkEmailBundle_FindByHeader($this->_cPtr,$headerFieldName,$headerFieldValue);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function FindEmail($json,$email) {
		return CkEmailBundle_FindEmail($this->_cPtr,$json,$email);
	}

	function GetEmail($index) {
		$r=CkEmailBundle_GetEmail($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function GetUidls() {
		$r=CkEmailBundle_GetUidls($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function getXml() {
		return CkEmailBundle_getXml($this->_cPtr);
	}

	function xml() {
		return CkEmailBundle_xml($this->_cPtr);
	}

	function LoadTaskResult($task) {
		return CkEmailBundle_LoadTaskResult($this->_cPtr,$task);
	}

	function LoadXml($filename) {
		return CkEmailBundle_LoadXml($this->_cPtr,$filename);
	}

	function LoadXmlString($xmlStr) {
		return CkEmailBundle_LoadXmlString($this->_cPtr,$xmlStr);
	}

	function RemoveEmail($email) {
		return CkEmailBundle_RemoveEmail($this->_cPtr,$email);
	}

	function RemoveEmailByIndex($index) {
		return CkEmailBundle_RemoveEmailByIndex($this->_cPtr,$index);
	}

	function SaveXml($filename) {
		return CkEmailBundle_SaveXml($this->_cPtr,$filename);
	}

	function SortByDate($ascending) {
		CkEmailBundle_SortByDate($this->_cPtr,$ascending);
	}

	function SortByRecipient($ascending) {
		CkEmailBundle_SortByRecipient($this->_cPtr,$ascending);
	}

	function SortBySender($ascending) {
		CkEmailBundle_SortBySender($this->_cPtr,$ascending);
	}

	function SortBySubject($ascending) {
		CkEmailBundle_SortBySubject($this->_cPtr,$ascending);
	}
}

class CkFileAccess {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkFileAccess') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkFileAccess();
	}

	function get_Utf8() {
		return CkFileAccess_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkFileAccess_put_Utf8($this->_cPtr,$b);
	}

	function get_CurrentDir($str) {
		CkFileAccess_get_CurrentDir($this->_cPtr,$str);
	}

	function currentDir() {
		return CkFileAccess_currentDir($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkFileAccess_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkFileAccess_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkFileAccess_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EndOfFile() {
		return CkFileAccess_get_EndOfFile($this->_cPtr);
	}

	function get_FileOpenError() {
		return CkFileAccess_get_FileOpenError($this->_cPtr);
	}

	function get_FileOpenErrorMsg($str) {
		CkFileAccess_get_FileOpenErrorMsg($this->_cPtr,$str);
	}

	function fileOpenErrorMsg() {
		return CkFileAccess_fileOpenErrorMsg($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkFileAccess_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkFileAccess_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkFileAccess_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkFileAccess_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkFileAccess_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkFileAccess_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkFileAccess_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkFileAccess_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LockFileOnOpen() {
		return CkFileAccess_get_LockFileOnOpen($this->_cPtr);
	}

	function put_LockFileOnOpen($newVal) {
		CkFileAccess_put_LockFileOnOpen($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkFileAccess_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkFileAccess_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkFileAccess_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkFileAccess_version($this->_cPtr);
	}

	function AppendAnsi($text) {
		return CkFileAccess_AppendAnsi($this->_cPtr,$text);
	}

	function AppendBd($bd) {
		return CkFileAccess_AppendBd($this->_cPtr,$bd);
	}

	function AppendSb($sb,$charset) {
		return CkFileAccess_AppendSb($this->_cPtr,$sb,$charset);
	}

	function AppendText($str,$charset) {
		return CkFileAccess_AppendText($this->_cPtr,$str,$charset);
	}

	function AppendUnicodeBOM() {
		return CkFileAccess_AppendUnicodeBOM($this->_cPtr);
	}

	function AppendUtf8BOM() {
		return CkFileAccess_AppendUtf8BOM($this->_cPtr);
	}

	function DirAutoCreate($filePath) {
		return CkFileAccess_DirAutoCreate($this->_cPtr,$filePath);
	}

	function DirCreate($dirPath) {
		return CkFileAccess_DirCreate($this->_cPtr,$dirPath);
	}

	function DirDelete($dirPath) {
		return CkFileAccess_DirDelete($this->_cPtr,$dirPath);
	}

	function DirEnsureExists($dirPath) {
		return CkFileAccess_DirEnsureExists($this->_cPtr,$dirPath);
	}

	function DirExists($dirPath) {
		return CkFileAccess_DirExists($this->_cPtr,$dirPath);
	}

	function FileClose() {
		CkFileAccess_FileClose($this->_cPtr);
	}

	function FileContentsEqual($filePath1,$filePath2) {
		return CkFileAccess_FileContentsEqual($this->_cPtr,$filePath1,$filePath2);
	}

	function FileCopy($existingFilepath,$newFilepath,$failIfExists) {
		return CkFileAccess_FileCopy($this->_cPtr,$existingFilepath,$newFilepath,$failIfExists);
	}

	function FileDelete($filePath) {
		return CkFileAccess_FileDelete($this->_cPtr,$filePath);
	}

	function FileExists($filePath) {
		return CkFileAccess_FileExists($this->_cPtr,$filePath);
	}

	function FileExists3($path) {
		return CkFileAccess_FileExists3($this->_cPtr,$path);
	}

	function FileOpen($filePath,$accessMode,$shareMode,$createDisposition,$attributes) {
		return CkFileAccess_FileOpen($this->_cPtr,$filePath,$accessMode,$shareMode,$createDisposition,$attributes);
	}

	function FileRead($maxNumBytes,$outBytes) {
		return CkFileAccess_FileRead($this->_cPtr,$maxNumBytes,$outBytes);
	}

	function FileReadBd($maxNumBytes,$binData) {
		return CkFileAccess_FileReadBd($this->_cPtr,$maxNumBytes,$binData);
	}

	function FileRename($existingFilepath,$newFilepath) {
		return CkFileAccess_FileRename($this->_cPtr,$existingFilepath,$newFilepath);
	}

	function FileSeek($offset,$origin) {
		return CkFileAccess_FileSeek($this->_cPtr,$offset,$origin);
	}

	function FileSize($filePath) {
		return CkFileAccess_FileSize($this->_cPtr,$filePath);
	}

	function fileSizeStr($filePath) {
		return CkFileAccess_fileSizeStr($this->_cPtr,$filePath);
	}

	function FileType($path) {
		return CkFileAccess_FileType($this->_cPtr,$path);
	}

	function FileWrite($data) {
		return CkFileAccess_FileWrite($this->_cPtr,$data);
	}

	function FileWriteBd($binData,$offset,$numBytes) {
		return CkFileAccess_FileWriteBd($this->_cPtr,$binData,$offset,$numBytes);
	}

	function genBlockId($index,$length,$encoding) {
		return CkFileAccess_genBlockId($this->_cPtr,$index,$length,$encoding);
	}

	function getDirectoryName($path) {
		return CkFileAccess_getDirectoryName($this->_cPtr,$path);
	}

	function directoryName($path) {
		return CkFileAccess_directoryName($this->_cPtr,$path);
	}

	function getExtension($path) {
		return CkFileAccess_getExtension($this->_cPtr,$path);
	}

	function extension($path) {
		return CkFileAccess_extension($this->_cPtr,$path);
	}

	function getFileName($path) {
		return CkFileAccess_getFileName($this->_cPtr,$path);
	}

	function fileName($path) {
		return CkFileAccess_fileName($this->_cPtr,$path);
	}

	function getFileNameWithoutExtension($path) {
		return CkFileAccess_getFileNameWithoutExtension($this->_cPtr,$path);
	}

	function fileNameWithoutExtension($path) {
		return CkFileAccess_fileNameWithoutExtension($this->_cPtr,$path);
	}

	function GetFileTime($path,$which) {
		$r=CkFileAccess_GetFileTime($this->_cPtr,$path,$which);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function getFileTimeStr($path,$which) {
		return CkFileAccess_getFileTimeStr($this->_cPtr,$path,$which);
	}

	function fileTimeStr($path,$which) {
		return CkFileAccess_fileTimeStr($this->_cPtr,$path,$which);
	}

	function GetLastModified($path) {
		$r=CkFileAccess_GetLastModified($this->_cPtr,$path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetNumBlocks($blockSize) {
		return CkFileAccess_GetNumBlocks($this->_cPtr,$blockSize);
	}

	function getTempFilename($dirPath,$prefix) {
		return CkFileAccess_getTempFilename($this->_cPtr,$dirPath,$prefix);
	}

	function tempFilename($dirPath,$prefix) {
		return CkFileAccess_tempFilename($this->_cPtr,$dirPath,$prefix);
	}

	function OpenForAppend($filePath) {
		return CkFileAccess_OpenForAppend($this->_cPtr,$filePath);
	}

	function OpenForRead($filePath) {
		return CkFileAccess_OpenForRead($this->_cPtr,$filePath);
	}

	function OpenForReadWrite($filePath) {
		return CkFileAccess_OpenForReadWrite($this->_cPtr,$filePath);
	}

	function OpenForWrite($filePath) {
		return CkFileAccess_OpenForWrite($this->_cPtr,$filePath);
	}

	function readBinaryToEncoded($filePath,$encoding) {
		return CkFileAccess_readBinaryToEncoded($this->_cPtr,$filePath,$encoding);
	}

	function ReadBlock($blockIndex,$blockSize,$outBytes) {
		return CkFileAccess_ReadBlock($this->_cPtr,$blockIndex,$blockSize,$outBytes);
	}

	function ReadBlockBd($blockIndex,$blockSize,$bd) {
		return CkFileAccess_ReadBlockBd($this->_cPtr,$blockIndex,$blockSize,$bd);
	}

	function ReadEntireFile($filePath,$outBytes) {
		return CkFileAccess_ReadEntireFile($this->_cPtr,$filePath,$outBytes);
	}

	function readEntireTextFile($filePath,$charset) {
		return CkFileAccess_readEntireTextFile($this->_cPtr,$filePath,$charset);
	}

	function ReadNextFragment($startAtBeginning,$beginMarker,$endMarker,$charset,$sb) {
		return CkFileAccess_ReadNextFragment($this->_cPtr,$startAtBeginning,$beginMarker,$endMarker,$charset,$sb);
	}

	function ReassembleFile($partsDirPath,$partPrefix,$partExtension,$reassembledFilename) {
		return CkFileAccess_ReassembleFile($this->_cPtr,$partsDirPath,$partPrefix,$partExtension,$reassembledFilename);
	}

	function ReplaceStrings($filePath,$charset,$existingString,$replacementString) {
		return CkFileAccess_ReplaceStrings($this->_cPtr,$filePath,$charset,$existingString,$replacementString);
	}

	function SetCurrentDir($dirPath) {
		return CkFileAccess_SetCurrentDir($this->_cPtr,$dirPath);
	}

	function SetFileTimes($filePath,$createTime,$lastAccessTime,$lastModTime) {
		return CkFileAccess_SetFileTimes($this->_cPtr,$filePath,$createTime,$lastAccessTime,$lastModTime);
	}

	function SetLastModified($filePath,$lastModified) {
		return CkFileAccess_SetLastModified($this->_cPtr,$filePath,$lastModified);
	}

	function SplitFile($fileToSplit,$partPrefix,$partExtension,$partSize,$destDir) {
		return CkFileAccess_SplitFile($this->_cPtr,$fileToSplit,$partPrefix,$partExtension,$partSize,$destDir);
	}

	function SymlinkCreate($targetPath,$linkPath) {
		return CkFileAccess_SymlinkCreate($this->_cPtr,$targetPath,$linkPath);
	}

	function symlinkTarget($linkPath) {
		return CkFileAccess_symlinkTarget($this->_cPtr,$linkPath);
	}

	function TreeDelete($path) {
		return CkFileAccess_TreeDelete($this->_cPtr,$path);
	}

	function Truncate() {
		return CkFileAccess_Truncate($this->_cPtr);
	}

	function WriteEntireFile($filePath,$fileData) {
		return CkFileAccess_WriteEntireFile($this->_cPtr,$filePath,$fileData);
	}

	function WriteEntireTextFile($filePath,$textData,$charset,$includedPreamble) {
		return CkFileAccess_WriteEntireTextFile($this->_cPtr,$filePath,$textData,$charset,$includedPreamble);
	}
}

class CkFtp2 {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkFtp2') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkFtp2();
	}

	function get_Utf8() {
		return CkFtp2_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkFtp2_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkFtp2_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkFtp2_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkFtp2_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_Account($str) {
		CkFtp2_get_Account($this->_cPtr,$str);
	}

	function account() {
		return CkFtp2_account($this->_cPtr);
	}

	function put_Account($newVal) {
		CkFtp2_put_Account($this->_cPtr,$newVal);
	}

	function get_ActivePortRangeEnd() {
		return CkFtp2_get_ActivePortRangeEnd($this->_cPtr);
	}

	function put_ActivePortRangeEnd($newVal) {
		CkFtp2_put_ActivePortRangeEnd($this->_cPtr,$newVal);
	}

	function get_ActivePortRangeStart() {
		return CkFtp2_get_ActivePortRangeStart($this->_cPtr);
	}

	function put_ActivePortRangeStart($newVal) {
		CkFtp2_put_ActivePortRangeStart($this->_cPtr,$newVal);
	}

	function get_AllocateSize() {
		return CkFtp2_get_AllocateSize($this->_cPtr);
	}

	function put_AllocateSize($newVal) {
		CkFtp2_put_AllocateSize($this->_cPtr,$newVal);
	}

	function get_AllowMlsd() {
		return CkFtp2_get_AllowMlsd($this->_cPtr);
	}

	function put_AllowMlsd($newVal) {
		CkFtp2_put_AllowMlsd($this->_cPtr,$newVal);
	}

	function get_AsyncBytesReceived() {
		return CkFtp2_get_AsyncBytesReceived($this->_cPtr);
	}

	function get_AsyncBytesReceived64() {
		return CkFtp2_get_AsyncBytesReceived64($this->_cPtr);
	}

	function get_AsyncBytesReceivedStr($str) {
		CkFtp2_get_AsyncBytesReceivedStr($this->_cPtr,$str);
	}

	function asyncBytesReceivedStr() {
		return CkFtp2_asyncBytesReceivedStr($this->_cPtr);
	}

	function get_AsyncBytesSent() {
		return CkFtp2_get_AsyncBytesSent($this->_cPtr);
	}

	function get_AsyncBytesSent64() {
		return CkFtp2_get_AsyncBytesSent64($this->_cPtr);
	}

	function get_AsyncBytesSentStr($str) {
		CkFtp2_get_AsyncBytesSentStr($this->_cPtr,$str);
	}

	function asyncBytesSentStr() {
		return CkFtp2_asyncBytesSentStr($this->_cPtr);
	}

	function get_AuthSsl() {
		return CkFtp2_get_AuthSsl($this->_cPtr);
	}

	function put_AuthSsl($newVal) {
		CkFtp2_put_AuthSsl($this->_cPtr,$newVal);
	}

	function get_AuthTls() {
		return CkFtp2_get_AuthTls($this->_cPtr);
	}

	function put_AuthTls($newVal) {
		CkFtp2_put_AuthTls($this->_cPtr,$newVal);
	}

	function get_AutoFeat() {
		return CkFtp2_get_AutoFeat($this->_cPtr);
	}

	function put_AutoFeat($newVal) {
		CkFtp2_put_AutoFeat($this->_cPtr,$newVal);
	}

	function get_AutoFix() {
		return CkFtp2_get_AutoFix($this->_cPtr);
	}

	function put_AutoFix($newVal) {
		CkFtp2_put_AutoFix($this->_cPtr,$newVal);
	}

	function get_AutoGetSizeForProgress() {
		return CkFtp2_get_AutoGetSizeForProgress($this->_cPtr);
	}

	function put_AutoGetSizeForProgress($newVal) {
		CkFtp2_put_AutoGetSizeForProgress($this->_cPtr,$newVal);
	}

	function get_AutoOptsUtf8() {
		return CkFtp2_get_AutoOptsUtf8($this->_cPtr);
	}

	function put_AutoOptsUtf8($newVal) {
		CkFtp2_put_AutoOptsUtf8($this->_cPtr,$newVal);
	}

	function get_AutoSetUseEpsv() {
		return CkFtp2_get_AutoSetUseEpsv($this->_cPtr);
	}

	function put_AutoSetUseEpsv($newVal) {
		CkFtp2_put_AutoSetUseEpsv($this->_cPtr,$newVal);
	}

	function get_AutoSyst() {
		return CkFtp2_get_AutoSyst($this->_cPtr);
	}

	function put_AutoSyst($newVal) {
		CkFtp2_put_AutoSyst($this->_cPtr,$newVal);
	}

	function get_AutoXcrc() {
		return CkFtp2_get_AutoXcrc($this->_cPtr);
	}

	function put_AutoXcrc($newVal) {
		CkFtp2_put_AutoXcrc($this->_cPtr,$newVal);
	}

	function get_BandwidthThrottleDown() {
		return CkFtp2_get_BandwidthThrottleDown($this->_cPtr);
	}

	function put_BandwidthThrottleDown($newVal) {
		CkFtp2_put_BandwidthThrottleDown($this->_cPtr,$newVal);
	}

	function get_BandwidthThrottleUp() {
		return CkFtp2_get_BandwidthThrottleUp($this->_cPtr);
	}

	function put_BandwidthThrottleUp($newVal) {
		CkFtp2_put_BandwidthThrottleUp($this->_cPtr,$newVal);
	}

	function get_ClientIpAddress($str) {
		CkFtp2_get_ClientIpAddress($this->_cPtr,$str);
	}

	function clientIpAddress() {
		return CkFtp2_clientIpAddress($this->_cPtr);
	}

	function put_ClientIpAddress($newVal) {
		CkFtp2_put_ClientIpAddress($this->_cPtr,$newVal);
	}

	function get_CommandCharset($str) {
		CkFtp2_get_CommandCharset($this->_cPtr,$str);
	}

	function commandCharset() {
		return CkFtp2_commandCharset($this->_cPtr);
	}

	function put_CommandCharset($newVal) {
		CkFtp2_put_CommandCharset($this->_cPtr,$newVal);
	}

	function get_ConnectFailReason() {
		return CkFtp2_get_ConnectFailReason($this->_cPtr);
	}

	function get_ConnectTimeout() {
		return CkFtp2_get_ConnectTimeout($this->_cPtr);
	}

	function put_ConnectTimeout($newVal) {
		CkFtp2_put_ConnectTimeout($this->_cPtr,$newVal);
	}

	function get_ConnectVerified() {
		return CkFtp2_get_ConnectVerified($this->_cPtr);
	}

	function get_CrlfMode() {
		return CkFtp2_get_CrlfMode($this->_cPtr);
	}

	function put_CrlfMode($newVal) {
		CkFtp2_put_CrlfMode($this->_cPtr,$newVal);
	}

	function get_CurBytesReceived() {
		return CkFtp2_get_CurBytesReceived($this->_cPtr);
	}

	function get_CurBytesReceived64() {
		return CkFtp2_get_CurBytesReceived64($this->_cPtr);
	}

	function get_CurBytesReceivedStr($str) {
		CkFtp2_get_CurBytesReceivedStr($this->_cPtr,$str);
	}

	function curBytesReceivedStr() {
		return CkFtp2_curBytesReceivedStr($this->_cPtr);
	}

	function get_CurBytesSent() {
		return CkFtp2_get_CurBytesSent($this->_cPtr);
	}

	function get_CurBytesSent64() {
		return CkFtp2_get_CurBytesSent64($this->_cPtr);
	}

	function get_CurBytesSentStr($str) {
		CkFtp2_get_CurBytesSentStr($this->_cPtr,$str);
	}

	function curBytesSentStr() {
		return CkFtp2_curBytesSentStr($this->_cPtr);
	}

	function get_DataProtection($str) {
		CkFtp2_get_DataProtection($this->_cPtr,$str);
	}

	function dataProtection() {
		return CkFtp2_dataProtection($this->_cPtr);
	}

	function put_DataProtection($newVal) {
		CkFtp2_put_DataProtection($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkFtp2_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkFtp2_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkFtp2_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DirListingCharset($str) {
		CkFtp2_get_DirListingCharset($this->_cPtr,$str);
	}

	function dirListingCharset() {
		return CkFtp2_dirListingCharset($this->_cPtr);
	}

	function put_DirListingCharset($newVal) {
		CkFtp2_put_DirListingCharset($this->_cPtr,$newVal);
	}

	function get_DownloadTransferRate() {
		return CkFtp2_get_DownloadTransferRate($this->_cPtr);
	}

	function get_ForcePortIpAddress($str) {
		CkFtp2_get_ForcePortIpAddress($this->_cPtr,$str);
	}

	function forcePortIpAddress() {
		return CkFtp2_forcePortIpAddress($this->_cPtr);
	}

	function put_ForcePortIpAddress($newVal) {
		CkFtp2_put_ForcePortIpAddress($this->_cPtr,$newVal);
	}

	function get_Greeting($str) {
		CkFtp2_get_Greeting($this->_cPtr,$str);
	}

	function greeting() {
		return CkFtp2_greeting($this->_cPtr);
	}

	function get_HasModeZ() {
		return CkFtp2_get_HasModeZ($this->_cPtr);
	}

	function get_HeartbeatMs() {
		return CkFtp2_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkFtp2_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_Hostname($str) {
		CkFtp2_get_Hostname($this->_cPtr,$str);
	}

	function hostname() {
		return CkFtp2_hostname($this->_cPtr);
	}

	function put_Hostname($newVal) {
		CkFtp2_put_Hostname($this->_cPtr,$newVal);
	}

	function get_HttpProxyAuthMethod($str) {
		CkFtp2_get_HttpProxyAuthMethod($this->_cPtr,$str);
	}

	function httpProxyAuthMethod() {
		return CkFtp2_httpProxyAuthMethod($this->_cPtr);
	}

	function put_HttpProxyAuthMethod($newVal) {
		CkFtp2_put_HttpProxyAuthMethod($this->_cPtr,$newVal);
	}

	function get_HttpProxyDomain($str) {
		CkFtp2_get_HttpProxyDomain($this->_cPtr,$str);
	}

	function httpProxyDomain() {
		return CkFtp2_httpProxyDomain($this->_cPtr);
	}

	function put_HttpProxyDomain($newVal) {
		CkFtp2_put_HttpProxyDomain($this->_cPtr,$newVal);
	}

	function get_HttpProxyHostname($str) {
		CkFtp2_get_HttpProxyHostname($this->_cPtr,$str);
	}

	function httpProxyHostname() {
		return CkFtp2_httpProxyHostname($this->_cPtr);
	}

	function put_HttpProxyHostname($newVal) {
		CkFtp2_put_HttpProxyHostname($this->_cPtr,$newVal);
	}

	function get_HttpProxyPassword($str) {
		CkFtp2_get_HttpProxyPassword($this->_cPtr,$str);
	}

	function httpProxyPassword() {
		return CkFtp2_httpProxyPassword($this->_cPtr);
	}

	function put_HttpProxyPassword($newVal) {
		CkFtp2_put_HttpProxyPassword($this->_cPtr,$newVal);
	}

	function get_HttpProxyPort() {
		return CkFtp2_get_HttpProxyPort($this->_cPtr);
	}

	function put_HttpProxyPort($newVal) {
		CkFtp2_put_HttpProxyPort($this->_cPtr,$newVal);
	}

	function get_HttpProxyUsername($str) {
		CkFtp2_get_HttpProxyUsername($this->_cPtr,$str);
	}

	function httpProxyUsername() {
		return CkFtp2_httpProxyUsername($this->_cPtr);
	}

	function put_HttpProxyUsername($newVal) {
		CkFtp2_put_HttpProxyUsername($this->_cPtr,$newVal);
	}

	function get_IdleTimeoutMs() {
		return CkFtp2_get_IdleTimeoutMs($this->_cPtr);
	}

	function put_IdleTimeoutMs($newVal) {
		CkFtp2_put_IdleTimeoutMs($this->_cPtr,$newVal);
	}

	function get_IsConnected() {
		return CkFtp2_get_IsConnected($this->_cPtr);
	}

	function get_KeepSessionLog() {
		return CkFtp2_get_KeepSessionLog($this->_cPtr);
	}

	function put_KeepSessionLog($newVal) {
		CkFtp2_put_KeepSessionLog($this->_cPtr,$newVal);
	}

	function get_LargeFileMeasures() {
		return CkFtp2_get_LargeFileMeasures($this->_cPtr);
	}

	function put_LargeFileMeasures($newVal) {
		CkFtp2_put_LargeFileMeasures($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkFtp2_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkFtp2_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkFtp2_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkFtp2_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkFtp2_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkFtp2_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkFtp2_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkFtp2_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LastReply($str) {
		CkFtp2_get_LastReply($this->_cPtr,$str);
	}

	function lastReply() {
		return CkFtp2_lastReply($this->_cPtr);
	}

	function get_ListPattern($str) {
		CkFtp2_get_ListPattern($this->_cPtr,$str);
	}

	function listPattern() {
		return CkFtp2_listPattern($this->_cPtr);
	}

	function put_ListPattern($newVal) {
		CkFtp2_put_ListPattern($this->_cPtr,$newVal);
	}

	function get_LoginVerified() {
		return CkFtp2_get_LoginVerified($this->_cPtr);
	}

	function get_PartialTransfer() {
		return CkFtp2_get_PartialTransfer($this->_cPtr);
	}

	function get_Passive() {
		return CkFtp2_get_Passive($this->_cPtr);
	}

	function put_Passive($newVal) {
		CkFtp2_put_Passive($this->_cPtr,$newVal);
	}

	function get_PassiveUseHostAddr() {
		return CkFtp2_get_PassiveUseHostAddr($this->_cPtr);
	}

	function put_PassiveUseHostAddr($newVal) {
		CkFtp2_put_PassiveUseHostAddr($this->_cPtr,$newVal);
	}

	function get_Password($str) {
		CkFtp2_get_Password($this->_cPtr,$str);
	}

	function password() {
		return CkFtp2_password($this->_cPtr);
	}

	function put_Password($newVal) {
		CkFtp2_put_Password($this->_cPtr,$newVal);
	}

	function get_PercentDoneScale() {
		return CkFtp2_get_PercentDoneScale($this->_cPtr);
	}

	function put_PercentDoneScale($newVal) {
		CkFtp2_put_PercentDoneScale($this->_cPtr,$newVal);
	}

	function get_Port() {
		return CkFtp2_get_Port($this->_cPtr);
	}

	function put_Port($newVal) {
		CkFtp2_put_Port($this->_cPtr,$newVal);
	}

	function get_PreferIpv6() {
		return CkFtp2_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkFtp2_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_PreferNlst() {
		return CkFtp2_get_PreferNlst($this->_cPtr);
	}

	function put_PreferNlst($newVal) {
		CkFtp2_put_PreferNlst($this->_cPtr,$newVal);
	}

	function get_ProgressMonSize() {
		return CkFtp2_get_ProgressMonSize($this->_cPtr);
	}

	function put_ProgressMonSize($newVal) {
		CkFtp2_put_ProgressMonSize($this->_cPtr,$newVal);
	}

	function get_ProgressMonSize64() {
		return CkFtp2_get_ProgressMonSize64($this->_cPtr);
	}

	function put_ProgressMonSize64($newVal) {
		CkFtp2_put_ProgressMonSize64($this->_cPtr,$newVal);
	}

	function get_ProxyHostname($str) {
		CkFtp2_get_ProxyHostname($this->_cPtr,$str);
	}

	function proxyHostname() {
		return CkFtp2_proxyHostname($this->_cPtr);
	}

	function put_ProxyHostname($newVal) {
		CkFtp2_put_ProxyHostname($this->_cPtr,$newVal);
	}

	function get_ProxyMethod() {
		return CkFtp2_get_ProxyMethod($this->_cPtr);
	}

	function put_ProxyMethod($newVal) {
		CkFtp2_put_ProxyMethod($this->_cPtr,$newVal);
	}

	function get_ProxyPassword($str) {
		CkFtp2_get_ProxyPassword($this->_cPtr,$str);
	}

	function proxyPassword() {
		return CkFtp2_proxyPassword($this->_cPtr);
	}

	function put_ProxyPassword($newVal) {
		CkFtp2_put_ProxyPassword($this->_cPtr,$newVal);
	}

	function get_ProxyPort() {
		return CkFtp2_get_ProxyPort($this->_cPtr);
	}

	function put_ProxyPort($newVal) {
		CkFtp2_put_ProxyPort($this->_cPtr,$newVal);
	}

	function get_ProxyUsername($str) {
		CkFtp2_get_ProxyUsername($this->_cPtr,$str);
	}

	function proxyUsername() {
		return CkFtp2_proxyUsername($this->_cPtr);
	}

	function put_ProxyUsername($newVal) {
		CkFtp2_put_ProxyUsername($this->_cPtr,$newVal);
	}

	function get_ReadTimeout() {
		return CkFtp2_get_ReadTimeout($this->_cPtr);
	}

	function put_ReadTimeout($newVal) {
		CkFtp2_put_ReadTimeout($this->_cPtr,$newVal);
	}

	function get_RequireSslCertVerify() {
		return CkFtp2_get_RequireSslCertVerify($this->_cPtr);
	}

	function put_RequireSslCertVerify($newVal) {
		CkFtp2_put_RequireSslCertVerify($this->_cPtr,$newVal);
	}

	function get_RestartNext() {
		return CkFtp2_get_RestartNext($this->_cPtr);
	}

	function put_RestartNext($newVal) {
		CkFtp2_put_RestartNext($this->_cPtr,$newVal);
	}

	function get_SessionLog($str) {
		CkFtp2_get_SessionLog($this->_cPtr,$str);
	}

	function sessionLog() {
		return CkFtp2_sessionLog($this->_cPtr);
	}

	function get_SocksHostname($str) {
		CkFtp2_get_SocksHostname($this->_cPtr,$str);
	}

	function socksHostname() {
		return CkFtp2_socksHostname($this->_cPtr);
	}

	function put_SocksHostname($newVal) {
		CkFtp2_put_SocksHostname($this->_cPtr,$newVal);
	}

	function get_SocksPassword($str) {
		CkFtp2_get_SocksPassword($this->_cPtr,$str);
	}

	function socksPassword() {
		return CkFtp2_socksPassword($this->_cPtr);
	}

	function put_SocksPassword($newVal) {
		CkFtp2_put_SocksPassword($this->_cPtr,$newVal);
	}

	function get_SocksPort() {
		return CkFtp2_get_SocksPort($this->_cPtr);
	}

	function put_SocksPort($newVal) {
		CkFtp2_put_SocksPort($this->_cPtr,$newVal);
	}

	function get_SocksUsername($str) {
		CkFtp2_get_SocksUsername($this->_cPtr,$str);
	}

	function socksUsername() {
		return CkFtp2_socksUsername($this->_cPtr);
	}

	function put_SocksUsername($newVal) {
		CkFtp2_put_SocksUsername($this->_cPtr,$newVal);
	}

	function get_SocksVersion() {
		return CkFtp2_get_SocksVersion($this->_cPtr);
	}

	function put_SocksVersion($newVal) {
		CkFtp2_put_SocksVersion($this->_cPtr,$newVal);
	}

	function get_SoRcvBuf() {
		return CkFtp2_get_SoRcvBuf($this->_cPtr);
	}

	function put_SoRcvBuf($newVal) {
		CkFtp2_put_SoRcvBuf($this->_cPtr,$newVal);
	}

	function get_SoSndBuf() {
		return CkFtp2_get_SoSndBuf($this->_cPtr);
	}

	function put_SoSndBuf($newVal) {
		CkFtp2_put_SoSndBuf($this->_cPtr,$newVal);
	}

	function get_Ssl() {
		return CkFtp2_get_Ssl($this->_cPtr);
	}

	function put_Ssl($newVal) {
		CkFtp2_put_Ssl($this->_cPtr,$newVal);
	}

	function get_SslAllowedCiphers($str) {
		CkFtp2_get_SslAllowedCiphers($this->_cPtr,$str);
	}

	function sslAllowedCiphers() {
		return CkFtp2_sslAllowedCiphers($this->_cPtr);
	}

	function put_SslAllowedCiphers($newVal) {
		CkFtp2_put_SslAllowedCiphers($this->_cPtr,$newVal);
	}

	function get_SslProtocol($str) {
		CkFtp2_get_SslProtocol($this->_cPtr,$str);
	}

	function sslProtocol() {
		return CkFtp2_sslProtocol($this->_cPtr);
	}

	function put_SslProtocol($newVal) {
		CkFtp2_put_SslProtocol($this->_cPtr,$newVal);
	}

	function get_SslServerCertVerified() {
		return CkFtp2_get_SslServerCertVerified($this->_cPtr);
	}

	function get_SyncCreateAllLocalDirs() {
		return CkFtp2_get_SyncCreateAllLocalDirs($this->_cPtr);
	}

	function put_SyncCreateAllLocalDirs($newVal) {
		CkFtp2_put_SyncCreateAllLocalDirs($this->_cPtr,$newVal);
	}

	function get_SyncMustMatch($str) {
		CkFtp2_get_SyncMustMatch($this->_cPtr,$str);
	}

	function syncMustMatch() {
		return CkFtp2_syncMustMatch($this->_cPtr);
	}

	function put_SyncMustMatch($newVal) {
		CkFtp2_put_SyncMustMatch($this->_cPtr,$newVal);
	}

	function get_SyncMustMatchDir($str) {
		CkFtp2_get_SyncMustMatchDir($this->_cPtr,$str);
	}

	function syncMustMatchDir() {
		return CkFtp2_syncMustMatchDir($this->_cPtr);
	}

	function put_SyncMustMatchDir($newVal) {
		CkFtp2_put_SyncMustMatchDir($this->_cPtr,$newVal);
	}

	function get_SyncMustNotMatch($str) {
		CkFtp2_get_SyncMustNotMatch($this->_cPtr,$str);
	}

	function syncMustNotMatch() {
		return CkFtp2_syncMustNotMatch($this->_cPtr);
	}

	function put_SyncMustNotMatch($newVal) {
		CkFtp2_put_SyncMustNotMatch($this->_cPtr,$newVal);
	}

	function get_SyncMustNotMatchDir($str) {
		CkFtp2_get_SyncMustNotMatchDir($this->_cPtr,$str);
	}

	function syncMustNotMatchDir() {
		return CkFtp2_syncMustNotMatchDir($this->_cPtr);
	}

	function put_SyncMustNotMatchDir($newVal) {
		CkFtp2_put_SyncMustNotMatchDir($this->_cPtr,$newVal);
	}

	function get_SyncPreview($str) {
		CkFtp2_get_SyncPreview($this->_cPtr,$str);
	}

	function syncPreview() {
		return CkFtp2_syncPreview($this->_cPtr);
	}

	function get_TlsCipherSuite($str) {
		CkFtp2_get_TlsCipherSuite($this->_cPtr,$str);
	}

	function tlsCipherSuite() {
		return CkFtp2_tlsCipherSuite($this->_cPtr);
	}

	function get_TlsPinSet($str) {
		CkFtp2_get_TlsPinSet($this->_cPtr,$str);
	}

	function tlsPinSet() {
		return CkFtp2_tlsPinSet($this->_cPtr);
	}

	function put_TlsPinSet($newVal) {
		CkFtp2_put_TlsPinSet($this->_cPtr,$newVal);
	}

	function get_TlsVersion($str) {
		CkFtp2_get_TlsVersion($this->_cPtr,$str);
	}

	function tlsVersion() {
		return CkFtp2_tlsVersion($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkFtp2_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkFtp2_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkFtp2_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UploadTransferRate() {
		return CkFtp2_get_UploadTransferRate($this->_cPtr);
	}

	function get_UseEpsv() {
		return CkFtp2_get_UseEpsv($this->_cPtr);
	}

	function put_UseEpsv($newVal) {
		CkFtp2_put_UseEpsv($this->_cPtr,$newVal);
	}

	function get_Username($str) {
		CkFtp2_get_Username($this->_cPtr,$str);
	}

	function username() {
		return CkFtp2_username($this->_cPtr);
	}

	function put_Username($newVal) {
		CkFtp2_put_Username($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkFtp2_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkFtp2_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkFtp2_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkFtp2_version($this->_cPtr);
	}

	function AppendFile($localFilePath,$remoteFilePath) {
		return CkFtp2_AppendFile($this->_cPtr,$localFilePath,$remoteFilePath);
	}

	function AppendFileAsync($localFilePath,$remoteFilePath) {
		$r=CkFtp2_AppendFileAsync($this->_cPtr,$localFilePath,$remoteFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendFileBd($remoteFilename,$bd) {
		return CkFtp2_AppendFileBd($this->_cPtr,$remoteFilename,$bd);
	}

	function AppendFileBdAsync($remoteFilename,$bd) {
		$r=CkFtp2_AppendFileBdAsync($this->_cPtr,$remoteFilename,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendFileFromBinaryData($remoteFilename,$content) {
		return CkFtp2_AppendFileFromBinaryData($this->_cPtr,$remoteFilename,$content);
	}

	function AppendFileFromBinaryDataAsync($remoteFilename,$content) {
		$r=CkFtp2_AppendFileFromBinaryDataAsync($this->_cPtr,$remoteFilename,$content);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendFileFromTextData($remoteFilename,$textData,$charset) {
		return CkFtp2_AppendFileFromTextData($this->_cPtr,$remoteFilename,$textData,$charset);
	}

	function AppendFileFromTextDataAsync($remoteFilename,$textData,$charset) {
		$r=CkFtp2_AppendFileFromTextDataAsync($this->_cPtr,$remoteFilename,$textData,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendFileSb($remoteFilename,$sb,$charset) {
		return CkFtp2_AppendFileSb($this->_cPtr,$remoteFilename,$sb,$charset);
	}

	function AppendFileSbAsync($remoteFilename,$sb,$charset) {
		$r=CkFtp2_AppendFileSbAsync($this->_cPtr,$remoteFilename,$sb,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChangeRemoteDir($remoteDirPath) {
		return CkFtp2_ChangeRemoteDir($this->_cPtr,$remoteDirPath);
	}

	function ChangeRemoteDirAsync($remoteDirPath) {
		$r=CkFtp2_ChangeRemoteDirAsync($this->_cPtr,$remoteDirPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CheckConnection() {
		return CkFtp2_CheckConnection($this->_cPtr);
	}

	function CheckConnectionAsync() {
		$r=CkFtp2_CheckConnectionAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ClearControlChannel() {
		return CkFtp2_ClearControlChannel($this->_cPtr);
	}

	function ClearControlChannelAsync() {
		$r=CkFtp2_ClearControlChannelAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ClearDirCache() {
		CkFtp2_ClearDirCache($this->_cPtr);
	}

	function ClearSessionLog() {
		CkFtp2_ClearSessionLog($this->_cPtr);
	}

	function Connect() {
		return CkFtp2_Connect($this->_cPtr);
	}

	function ConnectAsync() {
		$r=CkFtp2_ConnectAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ConnectOnly() {
		return CkFtp2_ConnectOnly($this->_cPtr);
	}

	function ConnectOnlyAsync() {
		$r=CkFtp2_ConnectOnlyAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ConvertToTls() {
		return CkFtp2_ConvertToTls($this->_cPtr);
	}

	function ConvertToTlsAsync() {
		$r=CkFtp2_ConvertToTlsAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function createPlan($localDir) {
		return CkFtp2_createPlan($this->_cPtr,$localDir);
	}

	function CreatePlanAsync($localDir) {
		$r=CkFtp2_CreatePlanAsync($this->_cPtr,$localDir);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CreateRemoteDir($remoteDirPath) {
		return CkFtp2_CreateRemoteDir($this->_cPtr,$remoteDirPath);
	}

	function CreateRemoteDirAsync($remoteDirPath) {
		$r=CkFtp2_CreateRemoteDirAsync($this->_cPtr,$remoteDirPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteMatching($remotePattern) {
		return CkFtp2_DeleteMatching($this->_cPtr,$remotePattern);
	}

	function DeleteMatchingAsync($remotePattern) {
		$r=CkFtp2_DeleteMatchingAsync($this->_cPtr,$remotePattern);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteRemoteFile($remoteFilePath) {
		return CkFtp2_DeleteRemoteFile($this->_cPtr,$remoteFilePath);
	}

	function DeleteRemoteFileAsync($remoteFilePath) {
		$r=CkFtp2_DeleteRemoteFileAsync($this->_cPtr,$remoteFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteTree() {
		return CkFtp2_DeleteTree($this->_cPtr);
	}

	function DeleteTreeAsync() {
		$r=CkFtp2_DeleteTreeAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DetermineProxyMethod() {
		return CkFtp2_DetermineProxyMethod($this->_cPtr);
	}

	function DetermineProxyMethodAsync() {
		$r=CkFtp2_DetermineProxyMethodAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function determineSettings() {
		return CkFtp2_determineSettings($this->_cPtr);
	}

	function DetermineSettingsAsync() {
		$r=CkFtp2_DetermineSettingsAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function dirTreeXml() {
		return CkFtp2_dirTreeXml($this->_cPtr);
	}

	function DirTreeXmlAsync() {
		$r=CkFtp2_DirTreeXmlAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Disconnect() {
		return CkFtp2_Disconnect($this->_cPtr);
	}

	function DisconnectAsync() {
		$r=CkFtp2_DisconnectAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DownloadTree($localRoot) {
		return CkFtp2_DownloadTree($this->_cPtr,$localRoot);
	}

	function DownloadTreeAsync($localRoot) {
		$r=CkFtp2_DownloadTreeAsync($this->_cPtr,$localRoot);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function feat() {
		return CkFtp2_feat($this->_cPtr);
	}

	function FeatAsync() {
		$r=CkFtp2_FeatAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetCreateDt($index) {
		$r=CkFtp2_GetCreateDt($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetCreateDtAsync($index) {
		$r=CkFtp2_GetCreateDtAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetCreateDtByName($filename) {
		$r=CkFtp2_GetCreateDtByName($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetCreateDtByNameAsync($filename) {
		$r=CkFtp2_GetCreateDtByNameAsync($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getCreateTimeByNameStr($filename) {
		return CkFtp2_getCreateTimeByNameStr($this->_cPtr,$filename);
	}

	function createTimeByNameStr($filename) {
		return CkFtp2_createTimeByNameStr($this->_cPtr,$filename);
	}

	function GetCreateTimeByNameStrAsync($filename) {
		$r=CkFtp2_GetCreateTimeByNameStrAsync($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getCreateTimeStr($index) {
		return CkFtp2_getCreateTimeStr($this->_cPtr,$index);
	}

	function createTimeStr($index) {
		return CkFtp2_createTimeStr($this->_cPtr,$index);
	}

	function GetCreateTimeStrAsync($index) {
		$r=CkFtp2_GetCreateTimeStrAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getCurrentRemoteDir() {
		return CkFtp2_getCurrentRemoteDir($this->_cPtr);
	}

	function currentRemoteDir() {
		return CkFtp2_currentRemoteDir($this->_cPtr);
	}

	function GetCurrentRemoteDirAsync() {
		$r=CkFtp2_GetCurrentRemoteDirAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetDirCount() {
		return CkFtp2_GetDirCount($this->_cPtr);
	}

	function GetDirCountAsync() {
		$r=CkFtp2_GetDirCountAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetFile($remoteFilePath,$localFilePath) {
		return CkFtp2_GetFile($this->_cPtr,$remoteFilePath,$localFilePath);
	}

	function GetFileAsync($remoteFilePath,$localFilePath) {
		$r=CkFtp2_GetFileAsync($this->_cPtr,$remoteFilePath,$localFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetFileBd($remoteFilePath,$binData) {
		return CkFtp2_GetFileBd($this->_cPtr,$remoteFilePath,$binData);
	}

	function GetFileBdAsync($remoteFilePath,$binData) {
		$r=CkFtp2_GetFileBdAsync($this->_cPtr,$remoteFilePath,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getFilename($index) {
		return CkFtp2_getFilename($this->_cPtr,$index);
	}

	function filename($index) {
		return CkFtp2_filename($this->_cPtr,$index);
	}

	function GetFilenameAsync($index) {
		$r=CkFtp2_GetFilenameAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetFileSb($remoteFilePath,$charset,$sb) {
		return CkFtp2_GetFileSb($this->_cPtr,$remoteFilePath,$charset,$sb);
	}

	function GetFileSbAsync($remoteFilePath,$charset,$sb) {
		$r=CkFtp2_GetFileSbAsync($this->_cPtr,$remoteFilePath,$charset,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetFileToStream($remoteFilePath,$toStream) {
		return CkFtp2_GetFileToStream($this->_cPtr,$remoteFilePath,$toStream);
	}

	function GetFileToStreamAsync($remoteFilePath,$toStream) {
		$r=CkFtp2_GetFileToStreamAsync($this->_cPtr,$remoteFilePath,$toStream);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getGroup($index) {
		return CkFtp2_getGroup($this->_cPtr,$index);
	}

	function group($index) {
		return CkFtp2_group($this->_cPtr,$index);
	}

	function GetGroupAsync($index) {
		$r=CkFtp2_GetGroupAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetIsDirectory($index) {
		return CkFtp2_GetIsDirectory($this->_cPtr,$index);
	}

	function GetIsDirectoryAsync($index) {
		$r=CkFtp2_GetIsDirectoryAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetIsSymbolicLink($index) {
		return CkFtp2_GetIsSymbolicLink($this->_cPtr,$index);
	}

	function GetIsSymbolicLinkAsync($index) {
		$r=CkFtp2_GetIsSymbolicLinkAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetLastModDt($index) {
		$r=CkFtp2_GetLastModDt($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetLastModDtAsync($index) {
		$r=CkFtp2_GetLastModDtAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetLastModDtByName($filename) {
		$r=CkFtp2_GetLastModDtByName($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetLastModDtByNameAsync($filename) {
		$r=CkFtp2_GetLastModDtByNameAsync($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getLastModifiedTimeByNameStr($filename) {
		return CkFtp2_getLastModifiedTimeByNameStr($this->_cPtr,$filename);
	}

	function lastModifiedTimeByNameStr($filename) {
		return CkFtp2_lastModifiedTimeByNameStr($this->_cPtr,$filename);
	}

	function GetLastModifiedTimeByNameStrAsync($filename) {
		$r=CkFtp2_GetLastModifiedTimeByNameStrAsync($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getLastModifiedTimeStr($index) {
		return CkFtp2_getLastModifiedTimeStr($this->_cPtr,$index);
	}

	function lastModifiedTimeStr($index) {
		return CkFtp2_lastModifiedTimeStr($this->_cPtr,$index);
	}

	function GetLastModifiedTimeStrAsync($index) {
		$r=CkFtp2_GetLastModifiedTimeStrAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getOwner($index) {
		return CkFtp2_getOwner($this->_cPtr,$index);
	}

	function owner($index) {
		return CkFtp2_owner($this->_cPtr,$index);
	}

	function GetOwnerAsync($index) {
		$r=CkFtp2_GetOwnerAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getPermissions($index) {
		return CkFtp2_getPermissions($this->_cPtr,$index);
	}

	function permissions($index) {
		return CkFtp2_permissions($this->_cPtr,$index);
	}

	function GetPermissionsAsync($index) {
		$r=CkFtp2_GetPermissionsAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getPermType($index) {
		return CkFtp2_getPermType($this->_cPtr,$index);
	}

	function permType($index) {
		return CkFtp2_permType($this->_cPtr,$index);
	}

	function GetPermTypeAsync($index) {
		$r=CkFtp2_GetPermTypeAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetRemoteFileBinaryData($remoteFilename,$outData) {
		return CkFtp2_GetRemoteFileBinaryData($this->_cPtr,$remoteFilename,$outData);
	}

	function GetRemoteFileBinaryDataAsync($remoteFilename) {
		$r=CkFtp2_GetRemoteFileBinaryDataAsync($this->_cPtr,$remoteFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getRemoteFileTextC($remoteFilename,$charset) {
		return CkFtp2_getRemoteFileTextC($this->_cPtr,$remoteFilename,$charset);
	}

	function remoteFileTextC($remoteFilename,$charset) {
		return CkFtp2_remoteFileTextC($this->_cPtr,$remoteFilename,$charset);
	}

	function GetRemoteFileTextCAsync($remoteFilename,$charset) {
		$r=CkFtp2_GetRemoteFileTextCAsync($this->_cPtr,$remoteFilename,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getRemoteFileTextData($remoteFilename) {
		return CkFtp2_getRemoteFileTextData($this->_cPtr,$remoteFilename);
	}

	function remoteFileTextData($remoteFilename) {
		return CkFtp2_remoteFileTextData($this->_cPtr,$remoteFilename);
	}

	function GetRemoteFileTextDataAsync($remoteFilename) {
		$r=CkFtp2_GetRemoteFileTextDataAsync($this->_cPtr,$remoteFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetServerCert($cert) {
		return CkFtp2_GetServerCert($this->_cPtr,$cert);
	}

	function GetSize($index) {
		return CkFtp2_GetSize($this->_cPtr,$index);
	}

	function GetSizeAsync($index) {
		$r=CkFtp2_GetSizeAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetSize64Async($index) {
		$r=CkFtp2_GetSize64Async($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetSizeByName($filename) {
		return CkFtp2_GetSizeByName($this->_cPtr,$filename);
	}

	function GetSizeByNameAsync($filename) {
		$r=CkFtp2_GetSizeByNameAsync($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetSizeByName64Async($filename) {
		$r=CkFtp2_GetSizeByName64Async($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getSizeStr($index) {
		return CkFtp2_getSizeStr($this->_cPtr,$index);
	}

	function sizeStr($index) {
		return CkFtp2_sizeStr($this->_cPtr,$index);
	}

	function GetSizeStrAsync($index) {
		$r=CkFtp2_GetSizeStrAsync($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getSizeStrByName($filename) {
		return CkFtp2_getSizeStrByName($this->_cPtr,$filename);
	}

	function sizeStrByName($filename) {
		return CkFtp2_sizeStrByName($this->_cPtr,$filename);
	}

	function GetSizeStrByNameAsync($filename) {
		$r=CkFtp2_GetSizeStrByNameAsync($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetSslServerCert() {
		$r=CkFtp2_GetSslServerCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetSyncedFiles($strTable) {
		CkFtp2_GetSyncedFiles($this->_cPtr,$strTable);
	}

	function getTextDirListing($pattern) {
		return CkFtp2_getTextDirListing($this->_cPtr,$pattern);
	}

	function textDirListing($pattern) {
		return CkFtp2_textDirListing($this->_cPtr,$pattern);
	}

	function GetTextDirListingAsync($pattern) {
		$r=CkFtp2_GetTextDirListingAsync($this->_cPtr,$pattern);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getXmlDirListing($pattern) {
		return CkFtp2_getXmlDirListing($this->_cPtr,$pattern);
	}

	function xmlDirListing($pattern) {
		return CkFtp2_xmlDirListing($this->_cPtr,$pattern);
	}

	function GetXmlDirListingAsync($pattern) {
		$r=CkFtp2_GetXmlDirListingAsync($this->_cPtr,$pattern);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LargeFileUpload($localPath,$remotePath,$chunkSize) {
		return CkFtp2_LargeFileUpload($this->_cPtr,$localPath,$remotePath,$chunkSize);
	}

	function LargeFileUploadAsync($localPath,$remotePath,$chunkSize) {
		$r=CkFtp2_LargeFileUploadAsync($this->_cPtr,$localPath,$remotePath,$chunkSize);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkFtp2_LoadTaskCaller($this->_cPtr,$task);
	}

	function LoginAfterConnectOnly() {
		return CkFtp2_LoginAfterConnectOnly($this->_cPtr);
	}

	function LoginAfterConnectOnlyAsync() {
		$r=CkFtp2_LoginAfterConnectOnlyAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function MGetFiles($remotePattern,$localDir) {
		return CkFtp2_MGetFiles($this->_cPtr,$remotePattern,$localDir);
	}

	function MGetFilesAsync($remotePattern,$localDir) {
		$r=CkFtp2_MGetFilesAsync($this->_cPtr,$remotePattern,$localDir);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function MPutFiles($pattern) {
		return CkFtp2_MPutFiles($this->_cPtr,$pattern);
	}

	function MPutFilesAsync($pattern) {
		$r=CkFtp2_MPutFilesAsync($this->_cPtr,$pattern);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function nlstXml($remoteDirPattern) {
		return CkFtp2_nlstXml($this->_cPtr,$remoteDirPattern);
	}

	function NlstXmlAsync($remoteDirPattern) {
		$r=CkFtp2_NlstXmlAsync($this->_cPtr,$remoteDirPattern);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Noop() {
		return CkFtp2_Noop($this->_cPtr);
	}

	function NoopAsync() {
		$r=CkFtp2_NoopAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PutFile($localFilePath,$remoteFilePath) {
		return CkFtp2_PutFile($this->_cPtr,$localFilePath,$remoteFilePath);
	}

	function PutFileAsync($localFilePath,$remoteFilePath) {
		$r=CkFtp2_PutFileAsync($this->_cPtr,$localFilePath,$remoteFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PutFileBd($binData,$remoteFilePath) {
		return CkFtp2_PutFileBd($this->_cPtr,$binData,$remoteFilePath);
	}

	function PutFileBdAsync($binData,$remoteFilePath) {
		$r=CkFtp2_PutFileBdAsync($this->_cPtr,$binData,$remoteFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PutFileFromBinaryData($remoteFilename,$content) {
		return CkFtp2_PutFileFromBinaryData($this->_cPtr,$remoteFilename,$content);
	}

	function PutFileFromBinaryDataAsync($remoteFilename,$content) {
		$r=CkFtp2_PutFileFromBinaryDataAsync($this->_cPtr,$remoteFilename,$content);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PutFileFromTextData($remoteFilename,$textData,$charset) {
		return CkFtp2_PutFileFromTextData($this->_cPtr,$remoteFilename,$textData,$charset);
	}

	function PutFileFromTextDataAsync($remoteFilename,$textData,$charset) {
		$r=CkFtp2_PutFileFromTextDataAsync($this->_cPtr,$remoteFilename,$textData,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PutFileSb($sb,$charset,$includeBom,$remoteFilePath) {
		return CkFtp2_PutFileSb($this->_cPtr,$sb,$charset,$includeBom,$remoteFilePath);
	}

	function PutFileSbAsync($sb,$charset,$includeBom,$remoteFilePath) {
		$r=CkFtp2_PutFileSbAsync($this->_cPtr,$sb,$charset,$includeBom,$remoteFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PutPlan($plan,$alreadyDoneFilename) {
		return CkFtp2_PutPlan($this->_cPtr,$plan,$alreadyDoneFilename);
	}

	function PutPlanAsync($plan,$alreadyDoneFilename) {
		$r=CkFtp2_PutPlanAsync($this->_cPtr,$plan,$alreadyDoneFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PutTree($localDir) {
		return CkFtp2_PutTree($this->_cPtr,$localDir);
	}

	function PutTreeAsync($localDir) {
		$r=CkFtp2_PutTreeAsync($this->_cPtr,$localDir);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Quote($cmd) {
		return CkFtp2_Quote($this->_cPtr,$cmd);
	}

	function QuoteAsync($cmd) {
		$r=CkFtp2_QuoteAsync($this->_cPtr,$cmd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RemoveRemoteDir($remoteDirPath) {
		return CkFtp2_RemoveRemoteDir($this->_cPtr,$remoteDirPath);
	}

	function RemoveRemoteDirAsync($remoteDirPath) {
		$r=CkFtp2_RemoveRemoteDirAsync($this->_cPtr,$remoteDirPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RenameRemoteFile($existingRemoteFilePath,$newRemoteFilePath) {
		return CkFtp2_RenameRemoteFile($this->_cPtr,$existingRemoteFilePath,$newRemoteFilePath);
	}

	function RenameRemoteFileAsync($existingRemoteFilePath,$newRemoteFilePath) {
		$r=CkFtp2_RenameRemoteFileAsync($this->_cPtr,$existingRemoteFilePath,$newRemoteFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function sendCommand($cmd) {
		return CkFtp2_sendCommand($this->_cPtr,$cmd);
	}

	function SendCommandAsync($cmd) {
		$r=CkFtp2_SendCommandAsync($this->_cPtr,$cmd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetModeZ() {
		return CkFtp2_SetModeZ($this->_cPtr);
	}

	function SetModeZAsync() {
		$r=CkFtp2_SetModeZAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetOldestDateStr($oldestDateTimeStr) {
		CkFtp2_SetOldestDateStr($this->_cPtr,$oldestDateTimeStr);
	}

	function SetOption($option) {
		return CkFtp2_SetOption($this->_cPtr,$option);
	}

	function SetPassword($password) {
		return CkFtp2_SetPassword($this->_cPtr,$password);
	}

	function SetRemoteFileDateTimeStr($dateTimeStr,$remoteFilename) {
		return CkFtp2_SetRemoteFileDateTimeStr($this->_cPtr,$dateTimeStr,$remoteFilename);
	}

	function SetRemoteFileDateTimeStrAsync($dateTimeStr,$remoteFilename) {
		$r=CkFtp2_SetRemoteFileDateTimeStrAsync($this->_cPtr,$dateTimeStr,$remoteFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetRemoteFileDt($dt,$remoteFilename) {
		return CkFtp2_SetRemoteFileDt($this->_cPtr,$dt,$remoteFilename);
	}

	function SetRemoteFileDtAsync($dt,$remoteFilename) {
		$r=CkFtp2_SetRemoteFileDtAsync($this->_cPtr,$dt,$remoteFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetSecurePassword($password) {
		return CkFtp2_SetSecurePassword($this->_cPtr,$password);
	}

	function SetSslCertRequirement($reqName,$reqValue) {
		CkFtp2_SetSslCertRequirement($this->_cPtr,$reqName,$reqValue);
	}

	function SetSslClientCert($cert) {
		return CkFtp2_SetSslClientCert($this->_cPtr,$cert);
	}

	function SetSslClientCertPem($pemDataOrFilename,$pemPassword) {
		return CkFtp2_SetSslClientCertPem($this->_cPtr,$pemDataOrFilename,$pemPassword);
	}

	function SetSslClientCertPfx($pfxFilename,$pfxPassword) {
		return CkFtp2_SetSslClientCertPfx($this->_cPtr,$pfxFilename,$pfxPassword);
	}

	function SetTypeAscii() {
		return CkFtp2_SetTypeAscii($this->_cPtr);
	}

	function SetTypeAsciiAsync() {
		$r=CkFtp2_SetTypeAsciiAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetTypeBinary() {
		return CkFtp2_SetTypeBinary($this->_cPtr);
	}

	function SetTypeBinaryAsync() {
		$r=CkFtp2_SetTypeBinaryAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Site($siteCommand) {
		return CkFtp2_Site($this->_cPtr,$siteCommand);
	}

	function SiteAsync($siteCommand) {
		$r=CkFtp2_SiteAsync($this->_cPtr,$siteCommand);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SleepMs($millisec) {
		CkFtp2_SleepMs($this->_cPtr,$millisec);
	}

	function ck_stat() {
		return CkFtp2_ck_stat($this->_cPtr);
	}

	function StatAsync() {
		$r=CkFtp2_StatAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SyncDeleteRemote($localRoot) {
		return CkFtp2_SyncDeleteRemote($this->_cPtr,$localRoot);
	}

	function SyncDeleteRemoteAsync($localRoot) {
		$r=CkFtp2_SyncDeleteRemoteAsync($this->_cPtr,$localRoot);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SyncLocalDir($localRoot,$mode) {
		return CkFtp2_SyncLocalDir($this->_cPtr,$localRoot,$mode);
	}

	function SyncLocalDirAsync($localRoot,$mode) {
		$r=CkFtp2_SyncLocalDirAsync($this->_cPtr,$localRoot,$mode);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SyncLocalTree($localRoot,$mode) {
		return CkFtp2_SyncLocalTree($this->_cPtr,$localRoot,$mode);
	}

	function SyncLocalTreeAsync($localRoot,$mode) {
		$r=CkFtp2_SyncLocalTreeAsync($this->_cPtr,$localRoot,$mode);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SyncRemoteTree($localRoot,$mode) {
		return CkFtp2_SyncRemoteTree($this->_cPtr,$localRoot,$mode);
	}

	function SyncRemoteTreeAsync($localRoot,$mode) {
		$r=CkFtp2_SyncRemoteTreeAsync($this->_cPtr,$localRoot,$mode);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SyncRemoteTree2($localDirPath,$mode,$bDescend,$bPreviewOnly) {
		return CkFtp2_SyncRemoteTree2($this->_cPtr,$localDirPath,$mode,$bDescend,$bPreviewOnly);
	}

	function SyncRemoteTree2Async($localDirPath,$mode,$bDescend,$bPreviewOnly) {
		$r=CkFtp2_SyncRemoteTree2Async($this->_cPtr,$localDirPath,$mode,$bDescend,$bPreviewOnly);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function syst() {
		return CkFtp2_syst($this->_cPtr);
	}

	function SystAsync() {
		$r=CkFtp2_SystAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkGlobal {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkGlobal') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkGlobal();
	}

	function get_Utf8() {
		return CkGlobal_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkGlobal_put_Utf8($this->_cPtr,$b);
	}

	function get_AnsiCodePage() {
		return CkGlobal_get_AnsiCodePage($this->_cPtr);
	}

	function put_AnsiCodePage($newVal) {
		CkGlobal_put_AnsiCodePage($this->_cPtr,$newVal);
	}

	function get_AutoQBDecode() {
		return CkGlobal_get_AutoQBDecode($this->_cPtr);
	}

	function put_AutoQBDecode($newVal) {
		CkGlobal_put_AutoQBDecode($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkGlobal_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkGlobal_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkGlobal_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DefaultNtlmVersion() {
		return CkGlobal_get_DefaultNtlmVersion($this->_cPtr);
	}

	function put_DefaultNtlmVersion($newVal) {
		CkGlobal_put_DefaultNtlmVersion($this->_cPtr,$newVal);
	}

	function get_DefaultUtf8() {
		return CkGlobal_get_DefaultUtf8($this->_cPtr);
	}

	function put_DefaultUtf8($newVal) {
		CkGlobal_put_DefaultUtf8($this->_cPtr,$newVal);
	}

	function get_DnsTimeToLive() {
		return CkGlobal_get_DnsTimeToLive($this->_cPtr);
	}

	function put_DnsTimeToLive($newVal) {
		CkGlobal_put_DnsTimeToLive($this->_cPtr,$newVal);
	}

	function get_EnableDnsCaching() {
		return CkGlobal_get_EnableDnsCaching($this->_cPtr);
	}

	function put_EnableDnsCaching($newVal) {
		CkGlobal_put_EnableDnsCaching($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkGlobal_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkGlobal_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkGlobal_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkGlobal_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkGlobal_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkGlobal_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkGlobal_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkGlobal_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_MaxThreads() {
		return CkGlobal_get_MaxThreads($this->_cPtr);
	}

	function put_MaxThreads($newVal) {
		CkGlobal_put_MaxThreads($this->_cPtr,$newVal);
	}

	function get_PreferIpv6() {
		return CkGlobal_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkGlobal_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_ThreadPoolLogPath($str) {
		CkGlobal_get_ThreadPoolLogPath($this->_cPtr,$str);
	}

	function threadPoolLogPath() {
		return CkGlobal_threadPoolLogPath($this->_cPtr);
	}

	function put_ThreadPoolLogPath($newVal) {
		CkGlobal_put_ThreadPoolLogPath($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkGlobal_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkGlobal_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkGlobal_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UnlockStatus() {
		return CkGlobal_get_UnlockStatus($this->_cPtr);
	}

	function get_UsePkcsConstructedEncoding() {
		return CkGlobal_get_UsePkcsConstructedEncoding($this->_cPtr);
	}

	function put_UsePkcsConstructedEncoding($newVal) {
		CkGlobal_put_UsePkcsConstructedEncoding($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkGlobal_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkGlobal_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_VerboseTls() {
		return CkGlobal_get_VerboseTls($this->_cPtr);
	}

	function put_VerboseTls($newVal) {
		CkGlobal_put_VerboseTls($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkGlobal_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkGlobal_version($this->_cPtr);
	}

	function DnsClearCache() {
		return CkGlobal_DnsClearCache($this->_cPtr);
	}

	function FinalizeThreadPool() {
		return CkGlobal_FinalizeThreadPool($this->_cPtr);
	}

	function ThreadPoolLogLine($str) {
		return CkGlobal_ThreadPoolLogLine($this->_cPtr,$str);
	}

	function UnlockBundle($bundleUnlockCode) {
		return CkGlobal_UnlockBundle($this->_cPtr,$bundleUnlockCode);
	}
}

class CkGzip {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkGzip') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkGzip();
	}

	function get_Utf8() {
		return CkGzip_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkGzip_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkGzip_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkGzip_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkGzip_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_Comment($str) {
		CkGzip_get_Comment($this->_cPtr,$str);
	}

	function comment() {
		return CkGzip_comment($this->_cPtr);
	}

	function put_Comment($newVal) {
		CkGzip_put_Comment($this->_cPtr,$newVal);
	}

	function get_CompressionLevel() {
		return CkGzip_get_CompressionLevel($this->_cPtr);
	}

	function put_CompressionLevel($newVal) {
		CkGzip_put_CompressionLevel($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkGzip_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkGzip_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkGzip_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Filename($str) {
		CkGzip_get_Filename($this->_cPtr,$str);
	}

	function filename() {
		return CkGzip_filename($this->_cPtr);
	}

	function put_Filename($newVal) {
		CkGzip_put_Filename($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkGzip_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkGzip_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkGzip_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkGzip_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkGzip_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkGzip_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkGzip_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkGzip_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkGzip_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkGzip_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LastModStr($str) {
		CkGzip_get_LastModStr($this->_cPtr,$str);
	}

	function lastModStr() {
		return CkGzip_lastModStr($this->_cPtr);
	}

	function put_LastModStr($newVal) {
		CkGzip_put_LastModStr($this->_cPtr,$newVal);
	}

	function get_UseCurrentDate() {
		return CkGzip_get_UseCurrentDate($this->_cPtr);
	}

	function put_UseCurrentDate($newVal) {
		CkGzip_put_UseCurrentDate($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkGzip_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkGzip_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkGzip_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkGzip_version($this->_cPtr);
	}

	function CompressBd($binDat) {
		return CkGzip_CompressBd($this->_cPtr,$binDat);
	}

	function CompressBdAsync($binDat) {
		$r=CkGzip_CompressBdAsync($this->_cPtr,$binDat);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressFile($inFilename,$destPath) {
		return CkGzip_CompressFile($this->_cPtr,$inFilename,$destPath);
	}

	function CompressFileAsync($inFilename,$destPath) {
		$r=CkGzip_CompressFileAsync($this->_cPtr,$inFilename,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressFile2($inFilename,$embeddedFilename,$destPath) {
		return CkGzip_CompressFile2($this->_cPtr,$inFilename,$embeddedFilename,$destPath);
	}

	function CompressFile2Async($inFilename,$embeddedFilename,$destPath) {
		$r=CkGzip_CompressFile2Async($this->_cPtr,$inFilename,$embeddedFilename,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressFileBd($filePath,$bd) {
		return CkGzip_CompressFileBd($this->_cPtr,$filePath,$bd);
	}

	function CompressFileBdAsync($filePath,$bd) {
		$r=CkGzip_CompressFileBdAsync($this->_cPtr,$filePath,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressFileToMem($inFilename,$outData) {
		return CkGzip_CompressFileToMem($this->_cPtr,$inFilename,$outData);
	}

	function CompressFileToMemAsync($inFilename) {
		$r=CkGzip_CompressFileToMemAsync($this->_cPtr,$inFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressMemory($inData,$outData) {
		return CkGzip_CompressMemory($this->_cPtr,$inData,$outData);
	}

	function CompressMemoryAsync($inData) {
		$r=CkGzip_CompressMemoryAsync($this->_cPtr,$inData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressMemToFile($inData,$destPath) {
		return CkGzip_CompressMemToFile($this->_cPtr,$inData,$destPath);
	}

	function CompressMemToFileAsync($inData,$destPath) {
		$r=CkGzip_CompressMemToFileAsync($this->_cPtr,$inData,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressSb($sb,$charset,$bd) {
		return CkGzip_CompressSb($this->_cPtr,$sb,$charset,$bd);
	}

	function CompressSbAsync($sb,$charset,$bd) {
		$r=CkGzip_CompressSbAsync($this->_cPtr,$sb,$charset,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressString($inStr,$destCharset,$outBytes) {
		return CkGzip_CompressString($this->_cPtr,$inStr,$destCharset,$outBytes);
	}

	function CompressStringAsync($inStr,$destCharset) {
		$r=CkGzip_CompressStringAsync($this->_cPtr,$inStr,$destCharset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function compressStringENC($inStr,$charset,$encoding) {
		return CkGzip_compressStringENC($this->_cPtr,$inStr,$charset,$encoding);
	}

	function CompressStringToFile($inStr,$destCharset,$destPath) {
		return CkGzip_CompressStringToFile($this->_cPtr,$inStr,$destCharset,$destPath);
	}

	function CompressStringToFileAsync($inStr,$destCharset,$destPath) {
		$r=CkGzip_CompressStringToFileAsync($this->_cPtr,$inStr,$destCharset,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Decode($encodedStr,$encoding,$outBytes) {
		return CkGzip_Decode($this->_cPtr,$encodedStr,$encoding,$outBytes);
	}

	function deflateStringENC($inString,$charsetName,$outputEncoding) {
		return CkGzip_deflateStringENC($this->_cPtr,$inString,$charsetName,$outputEncoding);
	}

	function encode($byteData,$encoding) {
		return CkGzip_encode($this->_cPtr,$byteData,$encoding);
	}

	function ExamineFile($inGzFilename) {
		return CkGzip_ExamineFile($this->_cPtr,$inGzFilename);
	}

	function ExamineMemory($inGzData) {
		return CkGzip_ExamineMemory($this->_cPtr,$inGzData);
	}

	function GetDt() {
		$r=CkGzip_GetDt($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function inflateStringENC($inString,$convertFromCharset,$inputEncoding) {
		return CkGzip_inflateStringENC($this->_cPtr,$inString,$convertFromCharset,$inputEncoding);
	}

	function IsGzip($bd) {
		return CkGzip_IsGzip($this->_cPtr,$bd);
	}

	function LoadTaskCaller($task) {
		return CkGzip_LoadTaskCaller($this->_cPtr,$task);
	}

	function ReadFile($path,$outBytes) {
		return CkGzip_ReadFile($this->_cPtr,$path,$outBytes);
	}

	function SetDt($dt) {
		return CkGzip_SetDt($this->_cPtr,$dt);
	}

	function SetExtraData($encodedData,$encoding) {
		return CkGzip_SetExtraData($this->_cPtr,$encodedData,$encoding);
	}

	function UncompressBd($binDat) {
		return CkGzip_UncompressBd($this->_cPtr,$binDat);
	}

	function UncompressBdAsync($binDat) {
		$r=CkGzip_UncompressBdAsync($this->_cPtr,$binDat);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressBdToFile($bd,$filePath) {
		return CkGzip_UncompressBdToFile($this->_cPtr,$bd,$filePath);
	}

	function UncompressBdToFileAsync($bd,$filePath) {
		$r=CkGzip_UncompressBdToFileAsync($this->_cPtr,$bd,$filePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressFile($srcPath,$destPath) {
		return CkGzip_UncompressFile($this->_cPtr,$srcPath,$destPath);
	}

	function UncompressFileAsync($srcPath,$destPath) {
		$r=CkGzip_UncompressFileAsync($this->_cPtr,$srcPath,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressFileToMem($inFilename,$outData) {
		return CkGzip_UncompressFileToMem($this->_cPtr,$inFilename,$outData);
	}

	function UncompressFileToMemAsync($inFilename) {
		$r=CkGzip_UncompressFileToMemAsync($this->_cPtr,$inFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function uncompressFileToString($gzFilename,$charset) {
		return CkGzip_uncompressFileToString($this->_cPtr,$gzFilename,$charset);
	}

	function UncompressFileToStringAsync($gzFilename,$charset) {
		$r=CkGzip_UncompressFileToStringAsync($this->_cPtr,$gzFilename,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressMemory($inData,$outData) {
		return CkGzip_UncompressMemory($this->_cPtr,$inData,$outData);
	}

	function UncompressMemoryAsync($inData) {
		$r=CkGzip_UncompressMemoryAsync($this->_cPtr,$inData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressMemToFile($inData,$destPath) {
		return CkGzip_UncompressMemToFile($this->_cPtr,$inData,$destPath);
	}

	function UncompressMemToFileAsync($inData,$destPath) {
		$r=CkGzip_UncompressMemToFileAsync($this->_cPtr,$inData,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function uncompressString($inData,$inCharset) {
		return CkGzip_uncompressString($this->_cPtr,$inData,$inCharset);
	}

	function UncompressStringAsync($inData,$inCharset) {
		$r=CkGzip_UncompressStringAsync($this->_cPtr,$inData,$inCharset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function uncompressStringENC($inStr,$charset,$encoding) {
		return CkGzip_uncompressStringENC($this->_cPtr,$inStr,$charset,$encoding);
	}

	function UnTarGz($tgzFilename,$destDir,$bNoAbsolute) {
		return CkGzip_UnTarGz($this->_cPtr,$tgzFilename,$destDir,$bNoAbsolute);
	}

	function UnTarGzAsync($tgzFilename,$destDir,$bNoAbsolute) {
		$r=CkGzip_UnTarGzAsync($this->_cPtr,$tgzFilename,$destDir,$bNoAbsolute);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteFile($path,$binaryData) {
		return CkGzip_WriteFile($this->_cPtr,$path,$binaryData);
	}

	function xfdlToXml($xfldData) {
		return CkGzip_xfdlToXml($this->_cPtr,$xfldData);
	}
}

class CkHashtable {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkHashtable') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkHashtable();
	}

	function get_Utf8() {
		return CkHashtable_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkHashtable_put_Utf8($this->_cPtr,$b);
	}

	function get_Count() {
		return CkHashtable_get_Count($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkHashtable_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkHashtable_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkHashtable_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkHashtable_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkHashtable_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkHashtable_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkHashtable_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkHashtable_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkHashtable_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkHashtable_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkHashtable_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkHashtable_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkHashtable_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkHashtable_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkHashtable_version($this->_cPtr);
	}

	function AddFromXmlSb($sbXml) {
		return CkHashtable_AddFromXmlSb($this->_cPtr,$sbXml);
	}

	function AddInt($key,$value) {
		return CkHashtable_AddInt($this->_cPtr,$key,$value);
	}

	function AddQueryParams($queryParams) {
		return CkHashtable_AddQueryParams($this->_cPtr,$queryParams);
	}

	function AddStr($key,$value) {
		return CkHashtable_AddStr($this->_cPtr,$key,$value);
	}

	function Clear() {
		CkHashtable_Clear($this->_cPtr);
	}

	function ClearWithNewCapacity($capacity) {
		return CkHashtable_ClearWithNewCapacity($this->_cPtr,$capacity);
	}

	function Contains($key) {
		return CkHashtable_Contains($this->_cPtr,$key);
	}

	function ContainsIntKey($key) {
		return CkHashtable_ContainsIntKey($this->_cPtr,$key);
	}

	function GetKeys($strTable) {
		return CkHashtable_GetKeys($this->_cPtr,$strTable);
	}

	function LookupInt($key) {
		return CkHashtable_LookupInt($this->_cPtr,$key);
	}

	function lookupStr($key) {
		return CkHashtable_lookupStr($this->_cPtr,$key);
	}

	function Remove($key) {
		return CkHashtable_Remove($this->_cPtr,$key);
	}

	function toQueryString() {
		return CkHashtable_toQueryString($this->_cPtr);
	}

	function ToXmlSb($sbXml) {
		return CkHashtable_ToXmlSb($this->_cPtr,$sbXml);
	}
}

class CkHtmlToText {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkHtmlToText') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkHtmlToText();
	}

	function get_Utf8() {
		return CkHtmlToText_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkHtmlToText_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkHtmlToText_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkHtmlToText_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkHtmlToText_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DecodeHtmlEntities() {
		return CkHtmlToText_get_DecodeHtmlEntities($this->_cPtr);
	}

	function put_DecodeHtmlEntities($newVal) {
		CkHtmlToText_put_DecodeHtmlEntities($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkHtmlToText_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkHtmlToText_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkHtmlToText_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkHtmlToText_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkHtmlToText_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkHtmlToText_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkHtmlToText_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkHtmlToText_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_RightMargin() {
		return CkHtmlToText_get_RightMargin($this->_cPtr);
	}

	function put_RightMargin($newVal) {
		CkHtmlToText_put_RightMargin($this->_cPtr,$newVal);
	}

	function get_SuppressLinks() {
		return CkHtmlToText_get_SuppressLinks($this->_cPtr);
	}

	function put_SuppressLinks($newVal) {
		CkHtmlToText_put_SuppressLinks($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkHtmlToText_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkHtmlToText_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkHtmlToText_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkHtmlToText_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkHtmlToText_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkHtmlToText_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkHtmlToText_version($this->_cPtr);
	}

	function readFileToString($filename,$srcCharset) {
		return CkHtmlToText_readFileToString($this->_cPtr,$filename,$srcCharset);
	}

	function toText($html) {
		return CkHtmlToText_toText($this->_cPtr,$html);
	}

	function ToTextSb($sb) {
		return CkHtmlToText_ToTextSb($this->_cPtr,$sb);
	}

	function WriteStringToFile($stringToWrite,$filename,$charset) {
		return CkHtmlToText_WriteStringToFile($this->_cPtr,$stringToWrite,$filename,$charset);
	}
}

class CkHtmlToXml {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkHtmlToXml') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkHtmlToXml();
	}

	function get_Utf8() {
		return CkHtmlToXml_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkHtmlToXml_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkHtmlToXml_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkHtmlToXml_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkHtmlToXml_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DropCustomTags() {
		return CkHtmlToXml_get_DropCustomTags($this->_cPtr);
	}

	function put_DropCustomTags($newVal) {
		CkHtmlToXml_put_DropCustomTags($this->_cPtr,$newVal);
	}

	function get_Html($str) {
		CkHtmlToXml_get_Html($this->_cPtr,$str);
	}

	function html() {
		return CkHtmlToXml_html($this->_cPtr);
	}

	function put_Html($newVal) {
		CkHtmlToXml_put_Html($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkHtmlToXml_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkHtmlToXml_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkHtmlToXml_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkHtmlToXml_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkHtmlToXml_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkHtmlToXml_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkHtmlToXml_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkHtmlToXml_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Nbsp() {
		return CkHtmlToXml_get_Nbsp($this->_cPtr);
	}

	function put_Nbsp($newVal) {
		CkHtmlToXml_put_Nbsp($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkHtmlToXml_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkHtmlToXml_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkHtmlToXml_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkHtmlToXml_version($this->_cPtr);
	}

	function get_XmlCharset($str) {
		CkHtmlToXml_get_XmlCharset($this->_cPtr,$str);
	}

	function xmlCharset() {
		return CkHtmlToXml_xmlCharset($this->_cPtr);
	}

	function put_XmlCharset($newVal) {
		CkHtmlToXml_put_XmlCharset($this->_cPtr,$newVal);
	}

	function ConvertFile($inHtmlPath,$destXmlPath) {
		return CkHtmlToXml_ConvertFile($this->_cPtr,$inHtmlPath,$destXmlPath);
	}

	function DropTagType($tagName) {
		CkHtmlToXml_DropTagType($this->_cPtr,$tagName);
	}

	function DropTextFormattingTags() {
		CkHtmlToXml_DropTextFormattingTags($this->_cPtr);
	}

	function ReadFile($path,$outBytes) {
		return CkHtmlToXml_ReadFile($this->_cPtr,$path,$outBytes);
	}

	function readFileToString($filename,$srcCharset) {
		return CkHtmlToXml_readFileToString($this->_cPtr,$filename,$srcCharset);
	}

	function SetHtmlBd($bd) {
		return CkHtmlToXml_SetHtmlBd($this->_cPtr,$bd);
	}

	function SetHtmlBytes($inData) {
		CkHtmlToXml_SetHtmlBytes($this->_cPtr,$inData);
	}

	function SetHtmlFromFile($filename) {
		return CkHtmlToXml_SetHtmlFromFile($this->_cPtr,$filename);
	}

	function SetHtmlSb($sb) {
		return CkHtmlToXml_SetHtmlSb($this->_cPtr,$sb);
	}

	function toXml() {
		return CkHtmlToXml_toXml($this->_cPtr);
	}

	function ToXmlSb($sb) {
		return CkHtmlToXml_ToXmlSb($this->_cPtr,$sb);
	}

	function UndropTagType($tagName) {
		CkHtmlToXml_UndropTagType($this->_cPtr,$tagName);
	}

	function UndropTextFormattingTags() {
		CkHtmlToXml_UndropTextFormattingTags($this->_cPtr);
	}

	function WriteFile($path,$fileData) {
		return CkHtmlToXml_WriteFile($this->_cPtr,$path,$fileData);
	}

	function WriteStringToFile($stringToWrite,$filename,$charset) {
		return CkHtmlToXml_WriteStringToFile($this->_cPtr,$stringToWrite,$filename,$charset);
	}

	function xml() {
		return CkHtmlToXml_xml($this->_cPtr);
	}
}

class CkHttp {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkHttp') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkHttp();
	}

	function get_Utf8() {
		return CkHttp_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkHttp_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkHttp_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkHttp_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkHttp_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_Accept($str) {
		CkHttp_get_Accept($this->_cPtr,$str);
	}

	function ck_accept() {
		return CkHttp_ck_accept($this->_cPtr);
	}

	function put_Accept($newVal) {
		CkHttp_put_Accept($this->_cPtr,$newVal);
	}

	function get_AcceptCharset($str) {
		CkHttp_get_AcceptCharset($this->_cPtr,$str);
	}

	function acceptCharset() {
		return CkHttp_acceptCharset($this->_cPtr);
	}

	function put_AcceptCharset($newVal) {
		CkHttp_put_AcceptCharset($this->_cPtr,$newVal);
	}

	function get_AcceptLanguage($str) {
		CkHttp_get_AcceptLanguage($this->_cPtr,$str);
	}

	function acceptLanguage() {
		return CkHttp_acceptLanguage($this->_cPtr);
	}

	function put_AcceptLanguage($newVal) {
		CkHttp_put_AcceptLanguage($this->_cPtr,$newVal);
	}

	function get_AllowGzip() {
		return CkHttp_get_AllowGzip($this->_cPtr);
	}

	function put_AllowGzip($newVal) {
		CkHttp_put_AllowGzip($this->_cPtr,$newVal);
	}

	function get_AllowHeaderFolding() {
		return CkHttp_get_AllowHeaderFolding($this->_cPtr);
	}

	function put_AllowHeaderFolding($newVal) {
		CkHttp_put_AllowHeaderFolding($this->_cPtr,$newVal);
	}

	function get_AuthSignature($str) {
		CkHttp_get_AuthSignature($this->_cPtr,$str);
	}

	function authSignature() {
		return CkHttp_authSignature($this->_cPtr);
	}

	function put_AuthSignature($newVal) {
		CkHttp_put_AuthSignature($this->_cPtr,$newVal);
	}

	function get_AuthToken($str) {
		CkHttp_get_AuthToken($this->_cPtr,$str);
	}

	function authToken() {
		return CkHttp_authToken($this->_cPtr);
	}

	function put_AuthToken($newVal) {
		CkHttp_put_AuthToken($this->_cPtr,$newVal);
	}

	function get_AutoAddHostHeader() {
		return CkHttp_get_AutoAddHostHeader($this->_cPtr);
	}

	function put_AutoAddHostHeader($newVal) {
		CkHttp_put_AutoAddHostHeader($this->_cPtr,$newVal);
	}

	function get_AwsAccessKey($str) {
		CkHttp_get_AwsAccessKey($this->_cPtr,$str);
	}

	function awsAccessKey() {
		return CkHttp_awsAccessKey($this->_cPtr);
	}

	function put_AwsAccessKey($newVal) {
		CkHttp_put_AwsAccessKey($this->_cPtr,$newVal);
	}

	function get_AwsEndpoint($str) {
		CkHttp_get_AwsEndpoint($this->_cPtr,$str);
	}

	function awsEndpoint() {
		return CkHttp_awsEndpoint($this->_cPtr);
	}

	function put_AwsEndpoint($newVal) {
		CkHttp_put_AwsEndpoint($this->_cPtr,$newVal);
	}

	function get_AwsRegion($str) {
		CkHttp_get_AwsRegion($this->_cPtr,$str);
	}

	function awsRegion() {
		return CkHttp_awsRegion($this->_cPtr);
	}

	function put_AwsRegion($newVal) {
		CkHttp_put_AwsRegion($this->_cPtr,$newVal);
	}

	function get_AwsSecretKey($str) {
		CkHttp_get_AwsSecretKey($this->_cPtr,$str);
	}

	function awsSecretKey() {
		return CkHttp_awsSecretKey($this->_cPtr);
	}

	function put_AwsSecretKey($newVal) {
		CkHttp_put_AwsSecretKey($this->_cPtr,$newVal);
	}

	function get_AwsSessionToken($str) {
		CkHttp_get_AwsSessionToken($this->_cPtr,$str);
	}

	function awsSessionToken() {
		return CkHttp_awsSessionToken($this->_cPtr);
	}

	function put_AwsSessionToken($newVal) {
		CkHttp_put_AwsSessionToken($this->_cPtr,$newVal);
	}

	function get_AwsSignatureVersion() {
		return CkHttp_get_AwsSignatureVersion($this->_cPtr);
	}

	function put_AwsSignatureVersion($newVal) {
		CkHttp_put_AwsSignatureVersion($this->_cPtr,$newVal);
	}

	function get_AwsSubResources($str) {
		CkHttp_get_AwsSubResources($this->_cPtr,$str);
	}

	function awsSubResources() {
		return CkHttp_awsSubResources($this->_cPtr);
	}

	function put_AwsSubResources($newVal) {
		CkHttp_put_AwsSubResources($this->_cPtr,$newVal);
	}

	function get_BandwidthThrottleDown() {
		return CkHttp_get_BandwidthThrottleDown($this->_cPtr);
	}

	function put_BandwidthThrottleDown($newVal) {
		CkHttp_put_BandwidthThrottleDown($this->_cPtr,$newVal);
	}

	function get_BandwidthThrottleUp() {
		return CkHttp_get_BandwidthThrottleUp($this->_cPtr);
	}

	function put_BandwidthThrottleUp($newVal) {
		CkHttp_put_BandwidthThrottleUp($this->_cPtr,$newVal);
	}

	function get_BasicAuth() {
		return CkHttp_get_BasicAuth($this->_cPtr);
	}

	function put_BasicAuth($newVal) {
		CkHttp_put_BasicAuth($this->_cPtr,$newVal);
	}

	function get_ClientIpAddress($str) {
		CkHttp_get_ClientIpAddress($this->_cPtr,$str);
	}

	function clientIpAddress() {
		return CkHttp_clientIpAddress($this->_cPtr);
	}

	function put_ClientIpAddress($newVal) {
		CkHttp_put_ClientIpAddress($this->_cPtr,$newVal);
	}

	function get_ConnectFailReason() {
		return CkHttp_get_ConnectFailReason($this->_cPtr);
	}

	function get_Connection($str) {
		CkHttp_get_Connection($this->_cPtr,$str);
	}

	function connection() {
		return CkHttp_connection($this->_cPtr);
	}

	function put_Connection($newVal) {
		CkHttp_put_Connection($this->_cPtr,$newVal);
	}

	function get_ConnectTimeout() {
		return CkHttp_get_ConnectTimeout($this->_cPtr);
	}

	function put_ConnectTimeout($newVal) {
		CkHttp_put_ConnectTimeout($this->_cPtr,$newVal);
	}

	function get_CookieDir($str) {
		CkHttp_get_CookieDir($this->_cPtr,$str);
	}

	function cookieDir() {
		return CkHttp_cookieDir($this->_cPtr);
	}

	function put_CookieDir($newVal) {
		CkHttp_put_CookieDir($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkHttp_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkHttp_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkHttp_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DefaultFreshPeriod() {
		return CkHttp_get_DefaultFreshPeriod($this->_cPtr);
	}

	function put_DefaultFreshPeriod($newVal) {
		CkHttp_put_DefaultFreshPeriod($this->_cPtr,$newVal);
	}

	function get_DigestAuth() {
		return CkHttp_get_DigestAuth($this->_cPtr);
	}

	function put_DigestAuth($newVal) {
		CkHttp_put_DigestAuth($this->_cPtr,$newVal);
	}

	function get_FetchFromCache() {
		return CkHttp_get_FetchFromCache($this->_cPtr);
	}

	function put_FetchFromCache($newVal) {
		CkHttp_put_FetchFromCache($this->_cPtr,$newVal);
	}

	function get_FinalRedirectUrl($str) {
		CkHttp_get_FinalRedirectUrl($this->_cPtr,$str);
	}

	function finalRedirectUrl() {
		return CkHttp_finalRedirectUrl($this->_cPtr);
	}

	function get_FollowRedirects() {
		return CkHttp_get_FollowRedirects($this->_cPtr);
	}

	function put_FollowRedirects($newVal) {
		CkHttp_put_FollowRedirects($this->_cPtr,$newVal);
	}

	function get_FreshnessAlgorithm() {
		return CkHttp_get_FreshnessAlgorithm($this->_cPtr);
	}

	function put_FreshnessAlgorithm($newVal) {
		CkHttp_put_FreshnessAlgorithm($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkHttp_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkHttp_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_IgnoreMustRevalidate() {
		return CkHttp_get_IgnoreMustRevalidate($this->_cPtr);
	}

	function put_IgnoreMustRevalidate($newVal) {
		CkHttp_put_IgnoreMustRevalidate($this->_cPtr,$newVal);
	}

	function get_IgnoreNoCache() {
		return CkHttp_get_IgnoreNoCache($this->_cPtr);
	}

	function put_IgnoreNoCache($newVal) {
		CkHttp_put_IgnoreNoCache($this->_cPtr,$newVal);
	}

	function get_KeepResponseBody() {
		return CkHttp_get_KeepResponseBody($this->_cPtr);
	}

	function put_KeepResponseBody($newVal) {
		CkHttp_put_KeepResponseBody($this->_cPtr,$newVal);
	}

	function get_LastContentType($str) {
		CkHttp_get_LastContentType($this->_cPtr,$str);
	}

	function lastContentType() {
		return CkHttp_lastContentType($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkHttp_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkHttp_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkHttp_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkHttp_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkHttp_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkHttp_lastErrorXml($this->_cPtr);
	}

	function get_LastFromCache() {
		return CkHttp_get_LastFromCache($this->_cPtr);
	}

	function get_LastHeader($str) {
		CkHttp_get_LastHeader($this->_cPtr,$str);
	}

	function lastHeader() {
		return CkHttp_lastHeader($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkHttp_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkHttp_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LastModDate($str) {
		CkHttp_get_LastModDate($this->_cPtr,$str);
	}

	function lastModDate() {
		return CkHttp_lastModDate($this->_cPtr);
	}

	function get_LastResponseBody($str) {
		CkHttp_get_LastResponseBody($this->_cPtr,$str);
	}

	function lastResponseBody() {
		return CkHttp_lastResponseBody($this->_cPtr);
	}

	function get_LastResponseHeader($str) {
		CkHttp_get_LastResponseHeader($this->_cPtr,$str);
	}

	function lastResponseHeader() {
		return CkHttp_lastResponseHeader($this->_cPtr);
	}

	function get_LastStatus() {
		return CkHttp_get_LastStatus($this->_cPtr);
	}

	function get_LastStatusText($str) {
		CkHttp_get_LastStatusText($this->_cPtr,$str);
	}

	function lastStatusText() {
		return CkHttp_lastStatusText($this->_cPtr);
	}

	function get_LMFactor() {
		return CkHttp_get_LMFactor($this->_cPtr);
	}

	function put_LMFactor($newVal) {
		CkHttp_put_LMFactor($this->_cPtr,$newVal);
	}

	function get_Login($str) {
		CkHttp_get_Login($this->_cPtr,$str);
	}

	function login() {
		return CkHttp_login($this->_cPtr);
	}

	function put_Login($newVal) {
		CkHttp_put_Login($this->_cPtr,$newVal);
	}

	function get_LoginDomain($str) {
		CkHttp_get_LoginDomain($this->_cPtr,$str);
	}

	function loginDomain() {
		return CkHttp_loginDomain($this->_cPtr);
	}

	function put_LoginDomain($newVal) {
		CkHttp_put_LoginDomain($this->_cPtr,$newVal);
	}

	function get_MaxConnections() {
		return CkHttp_get_MaxConnections($this->_cPtr);
	}

	function put_MaxConnections($newVal) {
		CkHttp_put_MaxConnections($this->_cPtr,$newVal);
	}

	function get_MaxFreshPeriod() {
		return CkHttp_get_MaxFreshPeriod($this->_cPtr);
	}

	function put_MaxFreshPeriod($newVal) {
		CkHttp_put_MaxFreshPeriod($this->_cPtr,$newVal);
	}

	function get_MaxResponseSize() {
		return CkHttp_get_MaxResponseSize($this->_cPtr);
	}

	function put_MaxResponseSize($newVal) {
		CkHttp_put_MaxResponseSize($this->_cPtr,$newVal);
	}

	function get_MaxUrlLen() {
		return CkHttp_get_MaxUrlLen($this->_cPtr);
	}

	function put_MaxUrlLen($newVal) {
		CkHttp_put_MaxUrlLen($this->_cPtr,$newVal);
	}

	function get_MimicFireFox() {
		return CkHttp_get_MimicFireFox($this->_cPtr);
	}

	function put_MimicFireFox($newVal) {
		CkHttp_put_MimicFireFox($this->_cPtr,$newVal);
	}

	function get_MimicIE() {
		return CkHttp_get_MimicIE($this->_cPtr);
	}

	function put_MimicIE($newVal) {
		CkHttp_put_MimicIE($this->_cPtr,$newVal);
	}

	function get_MinFreshPeriod() {
		return CkHttp_get_MinFreshPeriod($this->_cPtr);
	}

	function put_MinFreshPeriod($newVal) {
		CkHttp_put_MinFreshPeriod($this->_cPtr,$newVal);
	}

	function get_NegotiateAuth() {
		return CkHttp_get_NegotiateAuth($this->_cPtr);
	}

	function put_NegotiateAuth($newVal) {
		CkHttp_put_NegotiateAuth($this->_cPtr,$newVal);
	}

	function get_NtlmAuth() {
		return CkHttp_get_NtlmAuth($this->_cPtr);
	}

	function put_NtlmAuth($newVal) {
		CkHttp_put_NtlmAuth($this->_cPtr,$newVal);
	}

	function get_NumCacheLevels() {
		return CkHttp_get_NumCacheLevels($this->_cPtr);
	}

	function put_NumCacheLevels($newVal) {
		CkHttp_put_NumCacheLevels($this->_cPtr,$newVal);
	}

	function get_NumCacheRoots() {
		return CkHttp_get_NumCacheRoots($this->_cPtr);
	}

	function get_OAuth1() {
		return CkHttp_get_OAuth1($this->_cPtr);
	}

	function put_OAuth1($newVal) {
		CkHttp_put_OAuth1($this->_cPtr,$newVal);
	}

	function get_OAuthBodyHash() {
		return CkHttp_get_OAuthBodyHash($this->_cPtr);
	}

	function put_OAuthBodyHash($newVal) {
		CkHttp_put_OAuthBodyHash($this->_cPtr,$newVal);
	}

	function get_OAuthCallback($str) {
		CkHttp_get_OAuthCallback($this->_cPtr,$str);
	}

	function oAuthCallback() {
		return CkHttp_oAuthCallback($this->_cPtr);
	}

	function put_OAuthCallback($newVal) {
		CkHttp_put_OAuthCallback($this->_cPtr,$newVal);
	}

	function get_OAuthConsumerKey($str) {
		CkHttp_get_OAuthConsumerKey($this->_cPtr,$str);
	}

	function oAuthConsumerKey() {
		return CkHttp_oAuthConsumerKey($this->_cPtr);
	}

	function put_OAuthConsumerKey($newVal) {
		CkHttp_put_OAuthConsumerKey($this->_cPtr,$newVal);
	}

	function get_OAuthConsumerSecret($str) {
		CkHttp_get_OAuthConsumerSecret($this->_cPtr,$str);
	}

	function oAuthConsumerSecret() {
		return CkHttp_oAuthConsumerSecret($this->_cPtr);
	}

	function put_OAuthConsumerSecret($newVal) {
		CkHttp_put_OAuthConsumerSecret($this->_cPtr,$newVal);
	}

	function get_OAuthRealm($str) {
		CkHttp_get_OAuthRealm($this->_cPtr,$str);
	}

	function oAuthRealm() {
		return CkHttp_oAuthRealm($this->_cPtr);
	}

	function put_OAuthRealm($newVal) {
		CkHttp_put_OAuthRealm($this->_cPtr,$newVal);
	}

	function get_OAuthSigMethod($str) {
		CkHttp_get_OAuthSigMethod($this->_cPtr,$str);
	}

	function oAuthSigMethod() {
		return CkHttp_oAuthSigMethod($this->_cPtr);
	}

	function put_OAuthSigMethod($newVal) {
		CkHttp_put_OAuthSigMethod($this->_cPtr,$newVal);
	}

	function get_OAuthToken($str) {
		CkHttp_get_OAuthToken($this->_cPtr,$str);
	}

	function oAuthToken() {
		return CkHttp_oAuthToken($this->_cPtr);
	}

	function put_OAuthToken($newVal) {
		CkHttp_put_OAuthToken($this->_cPtr,$newVal);
	}

	function get_OAuthTokenSecret($str) {
		CkHttp_get_OAuthTokenSecret($this->_cPtr,$str);
	}

	function oAuthTokenSecret() {
		return CkHttp_oAuthTokenSecret($this->_cPtr);
	}

	function put_OAuthTokenSecret($newVal) {
		CkHttp_put_OAuthTokenSecret($this->_cPtr,$newVal);
	}

	function get_OAuthVerifier($str) {
		CkHttp_get_OAuthVerifier($this->_cPtr,$str);
	}

	function oAuthVerifier() {
		return CkHttp_oAuthVerifier($this->_cPtr);
	}

	function put_OAuthVerifier($newVal) {
		CkHttp_put_OAuthVerifier($this->_cPtr,$newVal);
	}

	function get_Password($str) {
		CkHttp_get_Password($this->_cPtr,$str);
	}

	function password() {
		return CkHttp_password($this->_cPtr);
	}

	function put_Password($newVal) {
		CkHttp_put_Password($this->_cPtr,$newVal);
	}

	function get_PercentDoneScale() {
		return CkHttp_get_PercentDoneScale($this->_cPtr);
	}

	function put_PercentDoneScale($newVal) {
		CkHttp_put_PercentDoneScale($this->_cPtr,$newVal);
	}

	function get_PreferIpv6() {
		return CkHttp_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkHttp_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_ProxyAuthMethod($str) {
		CkHttp_get_ProxyAuthMethod($this->_cPtr,$str);
	}

	function proxyAuthMethod() {
		return CkHttp_proxyAuthMethod($this->_cPtr);
	}

	function put_ProxyAuthMethod($newVal) {
		CkHttp_put_ProxyAuthMethod($this->_cPtr,$newVal);
	}

	function get_ProxyDirectTls() {
		return CkHttp_get_ProxyDirectTls($this->_cPtr);
	}

	function put_ProxyDirectTls($newVal) {
		CkHttp_put_ProxyDirectTls($this->_cPtr,$newVal);
	}

	function get_ProxyDomain($str) {
		CkHttp_get_ProxyDomain($this->_cPtr,$str);
	}

	function proxyDomain() {
		return CkHttp_proxyDomain($this->_cPtr);
	}

	function put_ProxyDomain($newVal) {
		CkHttp_put_ProxyDomain($this->_cPtr,$newVal);
	}

	function get_ProxyLogin($str) {
		CkHttp_get_ProxyLogin($this->_cPtr,$str);
	}

	function proxyLogin() {
		return CkHttp_proxyLogin($this->_cPtr);
	}

	function put_ProxyLogin($newVal) {
		CkHttp_put_ProxyLogin($this->_cPtr,$newVal);
	}

	function get_ProxyLoginDomain($str) {
		CkHttp_get_ProxyLoginDomain($this->_cPtr,$str);
	}

	function proxyLoginDomain() {
		return CkHttp_proxyLoginDomain($this->_cPtr);
	}

	function put_ProxyLoginDomain($newVal) {
		CkHttp_put_ProxyLoginDomain($this->_cPtr,$newVal);
	}

	function get_ProxyPassword($str) {
		CkHttp_get_ProxyPassword($this->_cPtr,$str);
	}

	function proxyPassword() {
		return CkHttp_proxyPassword($this->_cPtr);
	}

	function put_ProxyPassword($newVal) {
		CkHttp_put_ProxyPassword($this->_cPtr,$newVal);
	}

	function get_ProxyPort() {
		return CkHttp_get_ProxyPort($this->_cPtr);
	}

	function put_ProxyPort($newVal) {
		CkHttp_put_ProxyPort($this->_cPtr,$newVal);
	}

	function get_ReadTimeout() {
		return CkHttp_get_ReadTimeout($this->_cPtr);
	}

	function put_ReadTimeout($newVal) {
		CkHttp_put_ReadTimeout($this->_cPtr,$newVal);
	}

	function get_ReceivedCertReq() {
		return CkHttp_get_ReceivedCertReq($this->_cPtr);
	}

	function get_RedirectVerb($str) {
		CkHttp_get_RedirectVerb($this->_cPtr,$str);
	}

	function redirectVerb() {
		return CkHttp_redirectVerb($this->_cPtr);
	}

	function put_RedirectVerb($newVal) {
		CkHttp_put_RedirectVerb($this->_cPtr,$newVal);
	}

	function get_Referer($str) {
		CkHttp_get_Referer($this->_cPtr,$str);
	}

	function referer() {
		return CkHttp_referer($this->_cPtr);
	}

	function put_Referer($newVal) {
		CkHttp_put_Referer($this->_cPtr,$newVal);
	}

	function get_RequiredContentType($str) {
		CkHttp_get_RequiredContentType($this->_cPtr,$str);
	}

	function requiredContentType() {
		return CkHttp_requiredContentType($this->_cPtr);
	}

	function put_RequiredContentType($newVal) {
		CkHttp_put_RequiredContentType($this->_cPtr,$newVal);
	}

	function get_RequireHostnameMatch() {
		return CkHttp_get_RequireHostnameMatch($this->_cPtr);
	}

	function put_RequireHostnameMatch($newVal) {
		CkHttp_put_RequireHostnameMatch($this->_cPtr,$newVal);
	}

	function get_RequireSslCertVerify() {
		return CkHttp_get_RequireSslCertVerify($this->_cPtr);
	}

	function put_RequireSslCertVerify($newVal) {
		CkHttp_put_RequireSslCertVerify($this->_cPtr,$newVal);
	}

	function get_SaveCookies() {
		return CkHttp_get_SaveCookies($this->_cPtr);
	}

	function put_SaveCookies($newVal) {
		CkHttp_put_SaveCookies($this->_cPtr,$newVal);
	}

	function get_SendBufferSize() {
		return CkHttp_get_SendBufferSize($this->_cPtr);
	}

	function put_SendBufferSize($newVal) {
		CkHttp_put_SendBufferSize($this->_cPtr,$newVal);
	}

	function get_SendCookies() {
		return CkHttp_get_SendCookies($this->_cPtr);
	}

	function put_SendCookies($newVal) {
		CkHttp_put_SendCookies($this->_cPtr,$newVal);
	}

	function get_SessionLogFilename($str) {
		CkHttp_get_SessionLogFilename($this->_cPtr,$str);
	}

	function sessionLogFilename() {
		return CkHttp_sessionLogFilename($this->_cPtr);
	}

	function put_SessionLogFilename($newVal) {
		CkHttp_put_SessionLogFilename($this->_cPtr,$newVal);
	}

	function get_SniHostname($str) {
		CkHttp_get_SniHostname($this->_cPtr,$str);
	}

	function sniHostname() {
		return CkHttp_sniHostname($this->_cPtr);
	}

	function put_SniHostname($newVal) {
		CkHttp_put_SniHostname($this->_cPtr,$newVal);
	}

	function get_SocksHostname($str) {
		CkHttp_get_SocksHostname($this->_cPtr,$str);
	}

	function socksHostname() {
		return CkHttp_socksHostname($this->_cPtr);
	}

	function put_SocksHostname($newVal) {
		CkHttp_put_SocksHostname($this->_cPtr,$newVal);
	}

	function get_SocksPassword($str) {
		CkHttp_get_SocksPassword($this->_cPtr,$str);
	}

	function socksPassword() {
		return CkHttp_socksPassword($this->_cPtr);
	}

	function put_SocksPassword($newVal) {
		CkHttp_put_SocksPassword($this->_cPtr,$newVal);
	}

	function get_SocksPort() {
		return CkHttp_get_SocksPort($this->_cPtr);
	}

	function put_SocksPort($newVal) {
		CkHttp_put_SocksPort($this->_cPtr,$newVal);
	}

	function get_SocksUsername($str) {
		CkHttp_get_SocksUsername($this->_cPtr,$str);
	}

	function socksUsername() {
		return CkHttp_socksUsername($this->_cPtr);
	}

	function put_SocksUsername($newVal) {
		CkHttp_put_SocksUsername($this->_cPtr,$newVal);
	}

	function get_SocksVersion() {
		return CkHttp_get_SocksVersion($this->_cPtr);
	}

	function put_SocksVersion($newVal) {
		CkHttp_put_SocksVersion($this->_cPtr,$newVal);
	}

	function get_SoRcvBuf() {
		return CkHttp_get_SoRcvBuf($this->_cPtr);
	}

	function put_SoRcvBuf($newVal) {
		CkHttp_put_SoRcvBuf($this->_cPtr,$newVal);
	}

	function get_SoSndBuf() {
		return CkHttp_get_SoSndBuf($this->_cPtr);
	}

	function put_SoSndBuf($newVal) {
		CkHttp_put_SoSndBuf($this->_cPtr,$newVal);
	}

	function get_SslAllowedCiphers($str) {
		CkHttp_get_SslAllowedCiphers($this->_cPtr,$str);
	}

	function sslAllowedCiphers() {
		return CkHttp_sslAllowedCiphers($this->_cPtr);
	}

	function put_SslAllowedCiphers($newVal) {
		CkHttp_put_SslAllowedCiphers($this->_cPtr,$newVal);
	}

	function get_SslProtocol($str) {
		CkHttp_get_SslProtocol($this->_cPtr,$str);
	}

	function sslProtocol() {
		return CkHttp_sslProtocol($this->_cPtr);
	}

	function put_SslProtocol($newVal) {
		CkHttp_put_SslProtocol($this->_cPtr,$newVal);
	}

	function get_StreamResponseBodyPath($str) {
		CkHttp_get_StreamResponseBodyPath($this->_cPtr,$str);
	}

	function streamResponseBodyPath() {
		return CkHttp_streamResponseBodyPath($this->_cPtr);
	}

	function put_StreamResponseBodyPath($newVal) {
		CkHttp_put_StreamResponseBodyPath($this->_cPtr,$newVal);
	}

	function get_TlsCipherSuite($str) {
		CkHttp_get_TlsCipherSuite($this->_cPtr,$str);
	}

	function tlsCipherSuite() {
		return CkHttp_tlsCipherSuite($this->_cPtr);
	}

	function get_TlsPinSet($str) {
		CkHttp_get_TlsPinSet($this->_cPtr,$str);
	}

	function tlsPinSet() {
		return CkHttp_tlsPinSet($this->_cPtr);
	}

	function put_TlsPinSet($newVal) {
		CkHttp_put_TlsPinSet($this->_cPtr,$newVal);
	}

	function get_TlsVersion($str) {
		CkHttp_get_TlsVersion($this->_cPtr,$str);
	}

	function tlsVersion() {
		return CkHttp_tlsVersion($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkHttp_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkHttp_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkHttp_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UpdateCache() {
		return CkHttp_get_UpdateCache($this->_cPtr);
	}

	function put_UpdateCache($newVal) {
		CkHttp_put_UpdateCache($this->_cPtr,$newVal);
	}

	function get_UseIEProxy() {
		return CkHttp_get_UseIEProxy($this->_cPtr);
	}

	function put_UseIEProxy($newVal) {
		CkHttp_put_UseIEProxy($this->_cPtr,$newVal);
	}

	function get_UserAgent($str) {
		CkHttp_get_UserAgent($this->_cPtr,$str);
	}

	function userAgent() {
		return CkHttp_userAgent($this->_cPtr);
	}

	function put_UserAgent($newVal) {
		CkHttp_put_UserAgent($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkHttp_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkHttp_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkHttp_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkHttp_version($this->_cPtr);
	}

	function get_WasRedirected() {
		return CkHttp_get_WasRedirected($this->_cPtr);
	}

	function AddCacheRoot($dir) {
		CkHttp_AddCacheRoot($this->_cPtr,$dir);
	}

	function ClearHeaders() {
		CkHttp_ClearHeaders($this->_cPtr);
	}

	function ClearInMemoryCookies() {
		CkHttp_ClearInMemoryCookies($this->_cPtr);
	}

	function ClearUrlVars() {
		CkHttp_ClearUrlVars($this->_cPtr);
	}

	function CloseAllConnections() {
		return CkHttp_CloseAllConnections($this->_cPtr);
	}

	function CloseAllConnectionsAsync() {
		$r=CkHttp_CloseAllConnectionsAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CreateOcspRequest($requestDetails,$ocspRequest) {
		return CkHttp_CreateOcspRequest($this->_cPtr,$requestDetails,$ocspRequest);
	}

	function CreateTimestampRequest($hashAlg,$hashVal,$reqPolicyOid,$addNonce,$reqTsaCert,$timestampToken) {
		return CkHttp_CreateTimestampRequest($this->_cPtr,$hashAlg,$hashVal,$reqPolicyOid,$addNonce,$reqTsaCert,$timestampToken);
	}

	function DnsCacheClear() {
		CkHttp_DnsCacheClear($this->_cPtr);
	}

	function Download($url,$localFilePath) {
		return CkHttp_Download($this->_cPtr,$url,$localFilePath);
	}

	function DownloadAsync($url,$localFilePath) {
		$r=CkHttp_DownloadAsync($this->_cPtr,$url,$localFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DownloadAppend($url,$appendToPath) {
		return CkHttp_DownloadAppend($this->_cPtr,$url,$appendToPath);
	}

	function DownloadAppendAsync($url,$appendToPath) {
		$r=CkHttp_DownloadAppendAsync($this->_cPtr,$url,$appendToPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DownloadBd($url,$binData) {
		return CkHttp_DownloadBd($this->_cPtr,$url,$binData);
	}

	function DownloadBdAsync($url,$binData) {
		$r=CkHttp_DownloadBdAsync($this->_cPtr,$url,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function downloadHash($url,$hashAlgorithm,$encoding) {
		return CkHttp_downloadHash($this->_cPtr,$url,$hashAlgorithm,$encoding);
	}

	function DownloadHashAsync($url,$hashAlgorithm,$encoding) {
		$r=CkHttp_DownloadHashAsync($this->_cPtr,$url,$hashAlgorithm,$encoding);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DownloadSb($url,$charset,$sb) {
		return CkHttp_DownloadSb($this->_cPtr,$url,$charset,$sb);
	}

	function DownloadSbAsync($url,$charset,$sb) {
		$r=CkHttp_DownloadSbAsync($this->_cPtr,$url,$charset,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function extractMetaRefreshUrl($htmlContent) {
		return CkHttp_extractMetaRefreshUrl($this->_cPtr,$htmlContent);
	}

	function g_SvcOauthAccessToken($iss,$scope,$subEmail,$numSec,$cert) {
		return CkHttp_g_SvcOauthAccessToken($this->_cPtr,$iss,$scope,$subEmail,$numSec,$cert);
	}

	function G_SvcOauthAccessTokenAsync($iss,$scope,$subEmail,$numSec,$cert) {
		$r=CkHttp_G_SvcOauthAccessTokenAsync($this->_cPtr,$iss,$scope,$subEmail,$numSec,$cert);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function g_SvcOauthAccessToken2($claimParams,$numSec,$cert) {
		return CkHttp_g_SvcOauthAccessToken2($this->_cPtr,$claimParams,$numSec,$cert);
	}

	function G_SvcOauthAccessToken2Async($claimParams,$numSec,$cert) {
		$r=CkHttp_G_SvcOauthAccessToken2Async($this->_cPtr,$claimParams,$numSec,$cert);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function genTimeStamp() {
		return CkHttp_genTimeStamp($this->_cPtr);
	}

	function getCacheRoot($index) {
		return CkHttp_getCacheRoot($this->_cPtr,$index);
	}

	function cacheRoot($index) {
		return CkHttp_cacheRoot($this->_cPtr,$index);
	}

	function getCookieXml($domain) {
		return CkHttp_getCookieXml($this->_cPtr,$domain);
	}

	function cookieXml($domain) {
		return CkHttp_cookieXml($this->_cPtr,$domain);
	}

	function getDomain($url) {
		return CkHttp_getDomain($this->_cPtr,$url);
	}

	function domain($url) {
		return CkHttp_domain($this->_cPtr,$url);
	}

	function GetHead($url) {
		$r=CkHttp_GetHead($this->_cPtr,$url);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function GetHeadAsync($url) {
		$r=CkHttp_GetHeadAsync($this->_cPtr,$url);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetLastJsonData($json) {
		CkHttp_GetLastJsonData($this->_cPtr,$json);
	}

	function getRequestHeader($name) {
		return CkHttp_getRequestHeader($this->_cPtr,$name);
	}

	function requestHeader($name) {
		return CkHttp_requestHeader($this->_cPtr,$name);
	}

	function GetServerCert($domain,$port,$cert) {
		return CkHttp_GetServerCert($this->_cPtr,$domain,$port,$cert);
	}

	function GetServerCertAsync($domain,$port,$cert) {
		$r=CkHttp_GetServerCertAsync($this->_cPtr,$domain,$port,$cert);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetServerSslCert($domain,$port) {
		$r=CkHttp_GetServerSslCert($this->_cPtr,$domain,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetServerSslCertAsync($domain,$port) {
		$r=CkHttp_GetServerSslCertAsync($this->_cPtr,$domain,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getUrlPath($url) {
		return CkHttp_getUrlPath($this->_cPtr,$url);
	}

	function urlPath($url) {
		return CkHttp_urlPath($this->_cPtr,$url);
	}

	function HasRequestHeader($name) {
		return CkHttp_HasRequestHeader($this->_cPtr,$name);
	}

	function HttpBd($verb,$url,$bd,$contentType,$response) {
		return CkHttp_HttpBd($this->_cPtr,$verb,$url,$bd,$contentType,$response);
	}

	function HttpBdAsync($verb,$url,$bd,$contentType,$response) {
		$r=CkHttp_HttpBdAsync($this->_cPtr,$verb,$url,$bd,$contentType,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HttpBinary($verb,$url,$byteData,$contentType,$response) {
		return CkHttp_HttpBinary($this->_cPtr,$verb,$url,$byteData,$contentType,$response);
	}

	function HttpBinaryAsync($verb,$url,$byteData,$contentType,$response) {
		$r=CkHttp_HttpBinaryAsync($this->_cPtr,$verb,$url,$byteData,$contentType,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HttpFile($verb,$url,$localFilePath,$contentType,$response) {
		return CkHttp_HttpFile($this->_cPtr,$verb,$url,$localFilePath,$contentType,$response);
	}

	function HttpFileAsync($verb,$url,$localFilePath,$contentType,$response) {
		$r=CkHttp_HttpFileAsync($this->_cPtr,$verb,$url,$localFilePath,$contentType,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HttpJson($verb,$url,$json,$contentType,$response) {
		return CkHttp_HttpJson($this->_cPtr,$verb,$url,$json,$contentType,$response);
	}

	function HttpJsonAsync($verb,$url,$json,$contentType,$response) {
		$r=CkHttp_HttpJsonAsync($this->_cPtr,$verb,$url,$json,$contentType,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HttpNoBody($verb,$url,$response) {
		return CkHttp_HttpNoBody($this->_cPtr,$verb,$url,$response);
	}

	function HttpNoBodyAsync($verb,$url,$response) {
		$r=CkHttp_HttpNoBodyAsync($this->_cPtr,$verb,$url,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HttpParams($verb,$url,$json,$response) {
		return CkHttp_HttpParams($this->_cPtr,$verb,$url,$json,$response);
	}

	function HttpParamsAsync($verb,$url,$json,$response) {
		$r=CkHttp_HttpParamsAsync($this->_cPtr,$verb,$url,$json,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HttpReq($url,$request,$response) {
		return CkHttp_HttpReq($this->_cPtr,$url,$request,$response);
	}

	function HttpReqAsync($url,$request,$response) {
		$r=CkHttp_HttpReqAsync($this->_cPtr,$url,$request,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HttpSb($verb,$url,$sb,$charset,$contentType,$response) {
		return CkHttp_HttpSb($this->_cPtr,$verb,$url,$sb,$charset,$contentType,$response);
	}

	function HttpSbAsync($verb,$url,$sb,$charset,$contentType,$response) {
		$r=CkHttp_HttpSbAsync($this->_cPtr,$verb,$url,$sb,$charset,$contentType,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HttpSReq($domain,$port,$ssl,$request,$response) {
		return CkHttp_HttpSReq($this->_cPtr,$domain,$port,$ssl,$request,$response);
	}

	function HttpSReqAsync($domain,$port,$ssl,$request,$response) {
		$r=CkHttp_HttpSReqAsync($this->_cPtr,$domain,$port,$ssl,$request,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HttpStr($verb,$url,$bodyStr,$charset,$contentType,$response) {
		return CkHttp_HttpStr($this->_cPtr,$verb,$url,$bodyStr,$charset,$contentType,$response);
	}

	function HttpStrAsync($verb,$url,$bodyStr,$charset,$contentType,$response) {
		$r=CkHttp_HttpStrAsync($this->_cPtr,$verb,$url,$bodyStr,$charset,$contentType,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LastJsonData() {
		$r=CkHttp_LastJsonData($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkHttp_LoadTaskCaller($this->_cPtr,$task);
	}

	function OcspCheck($domain,$port) {
		return CkHttp_OcspCheck($this->_cPtr,$domain,$port);
	}

	function OcspCheckAsync($domain,$port) {
		$r=CkHttp_OcspCheckAsync($this->_cPtr,$domain,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ParseOcspReply($ocspReply,$replyData) {
		return CkHttp_ParseOcspReply($this->_cPtr,$ocspReply,$replyData);
	}

	function PBinary($verb,$url,$byteData,$contentType,$md5,$gzip) {
		$r=CkHttp_PBinary($this->_cPtr,$verb,$url,$byteData,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function PBinaryAsync($verb,$url,$byteData,$contentType,$md5,$gzip) {
		$r=CkHttp_PBinaryAsync($this->_cPtr,$verb,$url,$byteData,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PBinaryBd($verb,$url,$data,$contentType,$md5,$gzip) {
		$r=CkHttp_PBinaryBd($this->_cPtr,$verb,$url,$data,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function PBinaryBdAsync($verb,$url,$data,$contentType,$md5,$gzip) {
		$r=CkHttp_PBinaryBdAsync($this->_cPtr,$verb,$url,$data,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PFile($verb,$url,$localFilePath,$contentType,$md5,$gzip) {
		$r=CkHttp_PFile($this->_cPtr,$verb,$url,$localFilePath,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function PFileAsync($verb,$url,$localFilePath,$contentType,$md5,$gzip) {
		$r=CkHttp_PFileAsync($this->_cPtr,$verb,$url,$localFilePath,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function postBinary($url,$byteData,$contentType,$md5,$gzip) {
		return CkHttp_postBinary($this->_cPtr,$url,$byteData,$contentType,$md5,$gzip);
	}

	function PostBinaryAsync($url,$byteData,$contentType,$md5,$gzip) {
		$r=CkHttp_PostBinaryAsync($this->_cPtr,$url,$byteData,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PostJson($url,$jsonText) {
		$r=CkHttp_PostJson($this->_cPtr,$url,$jsonText);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function PostJsonAsync($url,$jsonText) {
		$r=CkHttp_PostJsonAsync($this->_cPtr,$url,$jsonText);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PostJson2($url,$contentType,$jsonText) {
		$r=CkHttp_PostJson2($this->_cPtr,$url,$contentType,$jsonText);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function PostJson2Async($url,$contentType,$jsonText) {
		$r=CkHttp_PostJson2Async($this->_cPtr,$url,$contentType,$jsonText);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PostJson3($url,$contentType,$json) {
		$r=CkHttp_PostJson3($this->_cPtr,$url,$contentType,$json);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function PostJson3Async($url,$contentType,$json) {
		$r=CkHttp_PostJson3Async($this->_cPtr,$url,$contentType,$json);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PostUrlEncoded($url,$req) {
		$r=CkHttp_PostUrlEncoded($this->_cPtr,$url,$req);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function PostUrlEncodedAsync($url,$req) {
		$r=CkHttp_PostUrlEncodedAsync($this->_cPtr,$url,$req);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PostXml($endpointUrl,$xmlContent,$xmlCharset) {
		$r=CkHttp_PostXml($this->_cPtr,$endpointUrl,$xmlContent,$xmlCharset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function PostXmlAsync($endpointUrl,$xmlContent,$xmlCharset) {
		$r=CkHttp_PostXmlAsync($this->_cPtr,$endpointUrl,$xmlContent,$xmlCharset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PText($verb,$url,$textData,$charset,$contentType,$md5,$gzip) {
		$r=CkHttp_PText($this->_cPtr,$verb,$url,$textData,$charset,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function PTextAsync($verb,$url,$textData,$charset,$contentType,$md5,$gzip) {
		$r=CkHttp_PTextAsync($this->_cPtr,$verb,$url,$textData,$charset,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function PTextSb($verb,$url,$textData,$charset,$contentType,$md5,$gzip) {
		$r=CkHttp_PTextSb($this->_cPtr,$verb,$url,$textData,$charset,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function PTextSbAsync($verb,$url,$textData,$charset,$contentType,$md5,$gzip) {
		$r=CkHttp_PTextSbAsync($this->_cPtr,$verb,$url,$textData,$charset,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function putBinary($url,$byteData,$contentType,$md5,$gzip) {
		return CkHttp_putBinary($this->_cPtr,$url,$byteData,$contentType,$md5,$gzip);
	}

	function PutBinaryAsync($url,$byteData,$contentType,$md5,$gzip) {
		$r=CkHttp_PutBinaryAsync($this->_cPtr,$url,$byteData,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function putText($url,$textData,$charset,$contentType,$md5,$gzip) {
		return CkHttp_putText($this->_cPtr,$url,$textData,$charset,$contentType,$md5,$gzip);
	}

	function PutTextAsync($url,$textData,$charset,$contentType,$md5,$gzip) {
		$r=CkHttp_PutTextAsync($this->_cPtr,$url,$textData,$charset,$contentType,$md5,$gzip);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function quickDeleteStr($url) {
		return CkHttp_quickDeleteStr($this->_cPtr,$url);
	}

	function QuickDeleteStrAsync($url) {
		$r=CkHttp_QuickDeleteStrAsync($this->_cPtr,$url);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QuickGet($url,$outData) {
		return CkHttp_QuickGet($this->_cPtr,$url,$outData);
	}

	function QuickGetAsync($url) {
		$r=CkHttp_QuickGetAsync($this->_cPtr,$url);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QuickGetBd($url,$binData) {
		return CkHttp_QuickGetBd($this->_cPtr,$url,$binData);
	}

	function QuickGetBdAsync($url,$binData) {
		$r=CkHttp_QuickGetBdAsync($this->_cPtr,$url,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QuickGetObj($url) {
		$r=CkHttp_QuickGetObj($this->_cPtr,$url);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function QuickGetObjAsync($url) {
		$r=CkHttp_QuickGetObjAsync($this->_cPtr,$url);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QuickGetSb($url,$sbContent) {
		return CkHttp_QuickGetSb($this->_cPtr,$url,$sbContent);
	}

	function QuickGetSbAsync($url,$sbContent) {
		$r=CkHttp_QuickGetSbAsync($this->_cPtr,$url,$sbContent);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function quickGetStr($url) {
		return CkHttp_quickGetStr($this->_cPtr,$url);
	}

	function QuickGetStrAsync($url) {
		$r=CkHttp_QuickGetStrAsync($this->_cPtr,$url);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function quickPutStr($url) {
		return CkHttp_quickPutStr($this->_cPtr,$url);
	}

	function QuickPutStrAsync($url) {
		$r=CkHttp_QuickPutStrAsync($this->_cPtr,$url);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QuickRequest($verb,$url) {
		$r=CkHttp_QuickRequest($this->_cPtr,$verb,$url);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function QuickRequestAsync($verb,$url) {
		$r=CkHttp_QuickRequestAsync($this->_cPtr,$verb,$url);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QuickRequestParams($verb,$url,$json) {
		$r=CkHttp_QuickRequestParams($this->_cPtr,$verb,$url,$json);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function QuickRequestParamsAsync($verb,$url,$json) {
		$r=CkHttp_QuickRequestParamsAsync($this->_cPtr,$verb,$url,$json);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RemoveRequestHeader($name) {
		CkHttp_RemoveRequestHeader($this->_cPtr,$name);
	}

	function renderGet($url) {
		return CkHttp_renderGet($this->_cPtr,$url);
	}

	function ResumeDownload($url,$targetFilename) {
		return CkHttp_ResumeDownload($this->_cPtr,$url,$targetFilename);
	}

	function ResumeDownloadAsync($url,$targetFilename) {
		$r=CkHttp_ResumeDownloadAsync($this->_cPtr,$url,$targetFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ResumeDownloadBd($url,$binData) {
		return CkHttp_ResumeDownloadBd($this->_cPtr,$url,$binData);
	}

	function ResumeDownloadBdAsync($url,$binData) {
		$r=CkHttp_ResumeDownloadBdAsync($this->_cPtr,$url,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_CreateBucket($bucketPath) {
		return CkHttp_S3_CreateBucket($this->_cPtr,$bucketPath);
	}

	function S3_CreateBucketAsync($bucketPath) {
		$r=CkHttp_S3_CreateBucketAsync($this->_cPtr,$bucketPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_DeleteBucket($bucketPath) {
		return CkHttp_S3_DeleteBucket($this->_cPtr,$bucketPath);
	}

	function S3_DeleteBucketAsync($bucketPath) {
		$r=CkHttp_S3_DeleteBucketAsync($this->_cPtr,$bucketPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_DeleteMultipleObjects($bucketName,$objectNames) {
		$r=CkHttp_S3_DeleteMultipleObjects($this->_cPtr,$bucketName,$objectNames);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function S3_DeleteMultipleObjectsAsync($bucketName,$objectNames) {
		$r=CkHttp_S3_DeleteMultipleObjectsAsync($this->_cPtr,$bucketName,$objectNames);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_DeleteObject($bucketPath,$objectName) {
		return CkHttp_S3_DeleteObject($this->_cPtr,$bucketPath,$objectName);
	}

	function S3_DeleteObjectAsync($bucketPath,$objectName) {
		$r=CkHttp_S3_DeleteObjectAsync($this->_cPtr,$bucketPath,$objectName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_DeleteObjects($bucketName,$objectNames,$jsonResponse) {
		return CkHttp_S3_DeleteObjects($this->_cPtr,$bucketName,$objectNames,$jsonResponse);
	}

	function S3_DeleteObjectsAsync($bucketName,$objectNames,$jsonResponse) {
		$r=CkHttp_S3_DeleteObjectsAsync($this->_cPtr,$bucketName,$objectNames,$jsonResponse);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_DownloadBd($bucketPath,$objectName,$bd) {
		return CkHttp_S3_DownloadBd($this->_cPtr,$bucketPath,$objectName,$bd);
	}

	function S3_DownloadBdAsync($bucketPath,$objectName,$bd) {
		$r=CkHttp_S3_DownloadBdAsync($this->_cPtr,$bucketPath,$objectName,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_DownloadBytes($bucketPath,$objectName,$outBytes) {
		return CkHttp_S3_DownloadBytes($this->_cPtr,$bucketPath,$objectName,$outBytes);
	}

	function S3_DownloadBytesAsync($bucketPath,$objectName) {
		$r=CkHttp_S3_DownloadBytesAsync($this->_cPtr,$bucketPath,$objectName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_DownloadFile($bucketPath,$objectName,$localFilePath) {
		return CkHttp_S3_DownloadFile($this->_cPtr,$bucketPath,$objectName,$localFilePath);
	}

	function S3_DownloadFileAsync($bucketPath,$objectName,$localFilePath) {
		$r=CkHttp_S3_DownloadFileAsync($this->_cPtr,$bucketPath,$objectName,$localFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function s3_DownloadString($bucketPath,$objectName,$charset) {
		return CkHttp_s3_DownloadString($this->_cPtr,$bucketPath,$objectName,$charset);
	}

	function S3_DownloadStringAsync($bucketPath,$objectName,$charset) {
		$r=CkHttp_S3_DownloadStringAsync($this->_cPtr,$bucketPath,$objectName,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_FileExists($bucketPath,$objectName) {
		return CkHttp_S3_FileExists($this->_cPtr,$bucketPath,$objectName);
	}

	function S3_FileExistsAsync($bucketPath,$objectName) {
		$r=CkHttp_S3_FileExistsAsync($this->_cPtr,$bucketPath,$objectName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function s3_GenerateUrl($bucket,$path,$expire) {
		return CkHttp_s3_GenerateUrl($this->_cPtr,$bucket,$path,$expire);
	}

	function s3_GenerateUrlV4($useHttps,$bucketName,$path,$numSecondsValid,$awsService) {
		return CkHttp_s3_GenerateUrlV4($this->_cPtr,$useHttps,$bucketName,$path,$numSecondsValid,$awsService);
	}

	function s3_GenPresignedUrl($httpVerb,$useHttps,$bucketName,$path,$numSecondsValid,$awsService) {
		return CkHttp_s3_GenPresignedUrl($this->_cPtr,$httpVerb,$useHttps,$bucketName,$path,$numSecondsValid,$awsService);
	}

	function s3_ListBucketObjects($bucketPath) {
		return CkHttp_s3_ListBucketObjects($this->_cPtr,$bucketPath);
	}

	function S3_ListBucketObjectsAsync($bucketPath) {
		$r=CkHttp_S3_ListBucketObjectsAsync($this->_cPtr,$bucketPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function s3_ListBuckets() {
		return CkHttp_s3_ListBuckets($this->_cPtr);
	}

	function S3_ListBucketsAsync() {
		$r=CkHttp_S3_ListBucketsAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_UploadBd($bd,$contentType,$bucketPath,$objectName) {
		return CkHttp_S3_UploadBd($this->_cPtr,$bd,$contentType,$bucketPath,$objectName);
	}

	function S3_UploadBdAsync($bd,$contentType,$bucketPath,$objectName) {
		$r=CkHttp_S3_UploadBdAsync($this->_cPtr,$bd,$contentType,$bucketPath,$objectName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_UploadBytes($contentBytes,$contentType,$bucketPath,$objectName) {
		return CkHttp_S3_UploadBytes($this->_cPtr,$contentBytes,$contentType,$bucketPath,$objectName);
	}

	function S3_UploadBytesAsync($contentBytes,$contentType,$bucketPath,$objectName) {
		$r=CkHttp_S3_UploadBytesAsync($this->_cPtr,$contentBytes,$contentType,$bucketPath,$objectName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_UploadFile($localFilePath,$contentType,$bucketPath,$objectName) {
		return CkHttp_S3_UploadFile($this->_cPtr,$localFilePath,$contentType,$bucketPath,$objectName);
	}

	function S3_UploadFileAsync($localFilePath,$contentType,$bucketPath,$objectName) {
		$r=CkHttp_S3_UploadFileAsync($this->_cPtr,$localFilePath,$contentType,$bucketPath,$objectName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function S3_UploadString($objectContent,$charset,$contentType,$bucketPath,$objectName) {
		return CkHttp_S3_UploadString($this->_cPtr,$objectContent,$charset,$contentType,$bucketPath,$objectName);
	}

	function S3_UploadStringAsync($objectContent,$charset,$contentType,$bucketPath,$objectName) {
		$r=CkHttp_S3_UploadStringAsync($this->_cPtr,$objectContent,$charset,$contentType,$bucketPath,$objectName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetAuthPrivateKey($publicKeyId,$privKey) {
		return CkHttp_SetAuthPrivateKey($this->_cPtr,$publicKeyId,$privKey);
	}

	function SetAuthTokenSb($sb) {
		return CkHttp_SetAuthTokenSb($this->_cPtr,$sb);
	}

	function SetCookieXml($domain,$cookieXml) {
		return CkHttp_SetCookieXml($this->_cPtr,$domain,$cookieXml);
	}

	function SetOAuthRsaKey($privKey) {
		return CkHttp_SetOAuthRsaKey($this->_cPtr,$privKey);
	}

	function SetRequestHeader($headerFieldName,$headerFieldValue) {
		CkHttp_SetRequestHeader($this->_cPtr,$headerFieldName,$headerFieldValue);
	}

	function SetSecurePassword($password) {
		return CkHttp_SetSecurePassword($this->_cPtr,$password);
	}

	function SetSslCertRequirement($reqName,$reqValue) {
		CkHttp_SetSslCertRequirement($this->_cPtr,$reqName,$reqValue);
	}

	function SetSslClientCert($cert) {
		return CkHttp_SetSslClientCert($this->_cPtr,$cert);
	}

	function SetSslClientCertPem($pemDataOrPath,$pemPassword) {
		return CkHttp_SetSslClientCertPem($this->_cPtr,$pemDataOrPath,$pemPassword);
	}

	function SetSslClientCertPfx($pfxPath,$pfxPassword) {
		return CkHttp_SetSslClientCertPfx($this->_cPtr,$pfxPath,$pfxPassword);
	}

	function SetUrlVar($name,$value) {
		return CkHttp_SetUrlVar($this->_cPtr,$name,$value);
	}

	function SharePointOnlineAuth($siteUrl,$username,$password,$extraInfo) {
		return CkHttp_SharePointOnlineAuth($this->_cPtr,$siteUrl,$username,$password,$extraInfo);
	}

	function SharePointOnlineAuthAsync($siteUrl,$username,$password,$extraInfo) {
		$r=CkHttp_SharePointOnlineAuthAsync($this->_cPtr,$siteUrl,$username,$password,$extraInfo);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SleepMs($millisec) {
		CkHttp_SleepMs($this->_cPtr,$millisec);
	}

	function SynchronousRequest($domain,$port,$ssl,$req) {
		$r=CkHttp_SynchronousRequest($this->_cPtr,$domain,$port,$ssl,$req);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkHttpResponse($r);
		}
		return $r;
	}

	function SynchronousRequestAsync($domain,$port,$ssl,$req) {
		$r=CkHttp_SynchronousRequestAsync($this->_cPtr,$domain,$port,$ssl,$req);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function urlDecode($str) {
		return CkHttp_urlDecode($this->_cPtr,$str);
	}

	function urlEncode($str) {
		return CkHttp_urlEncode($this->_cPtr,$str);
	}

	function VerifyTimestampReply($timestampReply,$tsaCert) {
		return CkHttp_VerifyTimestampReply($this->_cPtr,$timestampReply,$tsaCert);
	}

	function xmlRpc($urlEndpoint,$xmlIn) {
		return CkHttp_xmlRpc($this->_cPtr,$urlEndpoint,$xmlIn);
	}

	function XmlRpcAsync($urlEndpoint,$xmlIn) {
		$r=CkHttp_XmlRpcAsync($this->_cPtr,$urlEndpoint,$xmlIn);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function xmlRpcPut($urlEndpoint,$xmlIn) {
		return CkHttp_xmlRpcPut($this->_cPtr,$urlEndpoint,$xmlIn);
	}

	function XmlRpcPutAsync($urlEndpoint,$xmlIn) {
		$r=CkHttp_XmlRpcPutAsync($this->_cPtr,$urlEndpoint,$xmlIn);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkHttpRequest {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkHttpRequest') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkHttpRequest();
	}

	function get_Utf8() {
		return CkHttpRequest_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkHttpRequest_put_Utf8($this->_cPtr,$b);
	}

	function get_Boundary($str) {
		CkHttpRequest_get_Boundary($this->_cPtr,$str);
	}

	function boundary() {
		return CkHttpRequest_boundary($this->_cPtr);
	}

	function put_Boundary($newVal) {
		CkHttpRequest_put_Boundary($this->_cPtr,$newVal);
	}

	function get_Charset($str) {
		CkHttpRequest_get_Charset($this->_cPtr,$str);
	}

	function charset() {
		return CkHttpRequest_charset($this->_cPtr);
	}

	function put_Charset($newVal) {
		CkHttpRequest_put_Charset($this->_cPtr,$newVal);
	}

	function get_ContentType($str) {
		CkHttpRequest_get_ContentType($this->_cPtr,$str);
	}

	function contentType() {
		return CkHttpRequest_contentType($this->_cPtr);
	}

	function put_ContentType($newVal) {
		CkHttpRequest_put_ContentType($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkHttpRequest_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkHttpRequest_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkHttpRequest_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EntireHeader($str) {
		CkHttpRequest_get_EntireHeader($this->_cPtr,$str);
	}

	function entireHeader() {
		return CkHttpRequest_entireHeader($this->_cPtr);
	}

	function put_EntireHeader($newVal) {
		CkHttpRequest_put_EntireHeader($this->_cPtr,$newVal);
	}

	function get_HttpVerb($str) {
		CkHttpRequest_get_HttpVerb($this->_cPtr,$str);
	}

	function httpVerb() {
		return CkHttpRequest_httpVerb($this->_cPtr);
	}

	function put_HttpVerb($newVal) {
		CkHttpRequest_put_HttpVerb($this->_cPtr,$newVal);
	}

	function get_HttpVersion($str) {
		CkHttpRequest_get_HttpVersion($this->_cPtr,$str);
	}

	function httpVersion() {
		return CkHttpRequest_httpVersion($this->_cPtr);
	}

	function put_HttpVersion($newVal) {
		CkHttpRequest_put_HttpVersion($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkHttpRequest_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkHttpRequest_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkHttpRequest_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkHttpRequest_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkHttpRequest_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkHttpRequest_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkHttpRequest_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkHttpRequest_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumHeaderFields() {
		return CkHttpRequest_get_NumHeaderFields($this->_cPtr);
	}

	function get_NumParams() {
		return CkHttpRequest_get_NumParams($this->_cPtr);
	}

	function get_Path($str) {
		CkHttpRequest_get_Path($this->_cPtr,$str);
	}

	function path() {
		return CkHttpRequest_path($this->_cPtr);
	}

	function put_Path($newVal) {
		CkHttpRequest_put_Path($this->_cPtr,$newVal);
	}

	function get_SendCharset() {
		return CkHttpRequest_get_SendCharset($this->_cPtr);
	}

	function put_SendCharset($newVal) {
		CkHttpRequest_put_SendCharset($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkHttpRequest_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkHttpRequest_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkHttpRequest_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkHttpRequest_version($this->_cPtr);
	}

	function AddBdForUpload($name,$remoteFilename,$byteData,$contentType) {
		return CkHttpRequest_AddBdForUpload($this->_cPtr,$name,$remoteFilename,$byteData,$contentType);
	}

	function AddBytesForUpload($name,$remoteFileName,$byteData) {
		return CkHttpRequest_AddBytesForUpload($this->_cPtr,$name,$remoteFileName,$byteData);
	}

	function AddBytesForUpload2($name,$remoteFileName,$byteData,$contentType) {
		return CkHttpRequest_AddBytesForUpload2($this->_cPtr,$name,$remoteFileName,$byteData,$contentType);
	}

	function AddFileForUpload($name,$filePath) {
		return CkHttpRequest_AddFileForUpload($this->_cPtr,$name,$filePath);
	}

	function AddFileForUpload2($name,$filePath,$contentType) {
		return CkHttpRequest_AddFileForUpload2($this->_cPtr,$name,$filePath,$contentType);
	}

	function AddHeader($name,$value) {
		CkHttpRequest_AddHeader($this->_cPtr,$name,$value);
	}

	function AddMwsSignature($domain,$mwsSecretKey) {
		return CkHttpRequest_AddMwsSignature($this->_cPtr,$domain,$mwsSecretKey);
	}

	function AddParam($name,$value) {
		CkHttpRequest_AddParam($this->_cPtr,$name,$value);
	}

	function AddStringForUpload($name,$filename,$strData,$charset) {
		return CkHttpRequest_AddStringForUpload($this->_cPtr,$name,$filename,$strData,$charset);
	}

	function AddStringForUpload2($name,$filename,$strData,$charset,$contentType) {
		return CkHttpRequest_AddStringForUpload2($this->_cPtr,$name,$filename,$strData,$charset,$contentType);
	}

	function AddSubHeader($index,$name,$value) {
		return CkHttpRequest_AddSubHeader($this->_cPtr,$index,$name,$value);
	}

	function GenerateRequestFile($path) {
		return CkHttpRequest_GenerateRequestFile($this->_cPtr,$path);
	}

	function generateRequestText() {
		return CkHttpRequest_generateRequestText($this->_cPtr);
	}

	function getHeaderField($name) {
		return CkHttpRequest_getHeaderField($this->_cPtr,$name);
	}

	function headerField($name) {
		return CkHttpRequest_headerField($this->_cPtr,$name);
	}

	function getHeaderName($index) {
		return CkHttpRequest_getHeaderName($this->_cPtr,$index);
	}

	function headerName($index) {
		return CkHttpRequest_headerName($this->_cPtr,$index);
	}

	function getHeaderValue($index) {
		return CkHttpRequest_getHeaderValue($this->_cPtr,$index);
	}

	function headerValue($index) {
		return CkHttpRequest_headerValue($this->_cPtr,$index);
	}

	function getParam($name) {
		return CkHttpRequest_getParam($this->_cPtr,$name);
	}

	function param($name) {
		return CkHttpRequest_param($this->_cPtr,$name);
	}

	function getParamName($index) {
		return CkHttpRequest_getParamName($this->_cPtr,$index);
	}

	function paramName($index) {
		return CkHttpRequest_paramName($this->_cPtr,$index);
	}

	function getParamValue($index) {
		return CkHttpRequest_getParamValue($this->_cPtr,$index);
	}

	function paramValue($index) {
		return CkHttpRequest_paramValue($this->_cPtr,$index);
	}

	function getUrlEncodedParams() {
		return CkHttpRequest_getUrlEncodedParams($this->_cPtr);
	}

	function urlEncodedParams() {
		return CkHttpRequest_urlEncodedParams($this->_cPtr);
	}

	function LoadBodyFromBd($requestBody) {
		return CkHttpRequest_LoadBodyFromBd($this->_cPtr,$requestBody);
	}

	function LoadBodyFromBytes($byteData) {
		return CkHttpRequest_LoadBodyFromBytes($this->_cPtr,$byteData);
	}

	function LoadBodyFromFile($filePath) {
		return CkHttpRequest_LoadBodyFromFile($this->_cPtr,$filePath);
	}

	function LoadBodyFromSb($requestBody,$charset) {
		return CkHttpRequest_LoadBodyFromSb($this->_cPtr,$requestBody,$charset);
	}

	function LoadBodyFromString($bodyStr,$charset) {
		return CkHttpRequest_LoadBodyFromString($this->_cPtr,$bodyStr,$charset);
	}

	function RemoveAllParams() {
		CkHttpRequest_RemoveAllParams($this->_cPtr);
	}

	function RemoveHeader($name) {
		return CkHttpRequest_RemoveHeader($this->_cPtr,$name);
	}

	function RemoveParam($name) {
		CkHttpRequest_RemoveParam($this->_cPtr,$name);
	}

	function SetFromUrl($url) {
		CkHttpRequest_SetFromUrl($this->_cPtr,$url);
	}

	function StreamBodyFromFile($filePath) {
		return CkHttpRequest_StreamBodyFromFile($this->_cPtr,$filePath);
	}

	function StreamChunkFromFile($path,$offset,$numBytes) {
		return CkHttpRequest_StreamChunkFromFile($this->_cPtr,$path,$offset,$numBytes);
	}
}

class CkHttpResponse {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkHttpResponse') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkHttpResponse();
	}

	function get_Utf8() {
		return CkHttpResponse_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkHttpResponse_put_Utf8($this->_cPtr,$b);
	}

	function get_BodyQP($str) {
		CkHttpResponse_get_BodyQP($this->_cPtr,$str);
	}

	function bodyQP() {
		return CkHttpResponse_bodyQP($this->_cPtr);
	}

	function get_BodyStr($str) {
		CkHttpResponse_get_BodyStr($this->_cPtr,$str);
	}

	function bodyStr() {
		return CkHttpResponse_bodyStr($this->_cPtr);
	}

	function get_Charset($str) {
		CkHttpResponse_get_Charset($this->_cPtr,$str);
	}

	function charset() {
		return CkHttpResponse_charset($this->_cPtr);
	}

	function get_ContentLength() {
		return CkHttpResponse_get_ContentLength($this->_cPtr);
	}

	function get_ContentLength64() {
		return CkHttpResponse_get_ContentLength64($this->_cPtr);
	}

	function get_DateStr($str) {
		CkHttpResponse_get_DateStr($this->_cPtr,$str);
	}

	function dateStr() {
		return CkHttpResponse_dateStr($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkHttpResponse_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkHttpResponse_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkHttpResponse_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Domain($str) {
		CkHttpResponse_get_Domain($this->_cPtr,$str);
	}

	function domain() {
		return CkHttpResponse_domain($this->_cPtr);
	}

	function get_FinalRedirectUrl($str) {
		CkHttpResponse_get_FinalRedirectUrl($this->_cPtr,$str);
	}

	function finalRedirectUrl() {
		return CkHttpResponse_finalRedirectUrl($this->_cPtr);
	}

	function get_FullMime($str) {
		CkHttpResponse_get_FullMime($this->_cPtr,$str);
	}

	function fullMime() {
		return CkHttpResponse_fullMime($this->_cPtr);
	}

	function get_Header($str) {
		CkHttpResponse_get_Header($this->_cPtr,$str);
	}

	function header() {
		return CkHttpResponse_header($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkHttpResponse_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkHttpResponse_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkHttpResponse_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkHttpResponse_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkHttpResponse_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkHttpResponse_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkHttpResponse_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkHttpResponse_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumCookies() {
		return CkHttpResponse_get_NumCookies($this->_cPtr);
	}

	function get_NumHeaderFields() {
		return CkHttpResponse_get_NumHeaderFields($this->_cPtr);
	}

	function get_StatusCode() {
		return CkHttpResponse_get_StatusCode($this->_cPtr);
	}

	function get_StatusLine($str) {
		CkHttpResponse_get_StatusLine($this->_cPtr,$str);
	}

	function statusLine() {
		return CkHttpResponse_statusLine($this->_cPtr);
	}

	function get_StatusText($str) {
		CkHttpResponse_get_StatusText($this->_cPtr,$str);
	}

	function statusText() {
		return CkHttpResponse_statusText($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkHttpResponse_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkHttpResponse_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkHttpResponse_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkHttpResponse_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkHttpResponse_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkHttpResponse_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkHttpResponse_version($this->_cPtr);
	}

	function GetBodyBd($binData) {
		return CkHttpResponse_GetBodyBd($this->_cPtr,$binData);
	}

	function GetBodyJarr($jarr) {
		return CkHttpResponse_GetBodyJarr($this->_cPtr,$jarr);
	}

	function GetBodyJson($json) {
		return CkHttpResponse_GetBodyJson($this->_cPtr,$json);
	}

	function GetBodySb($sb) {
		return CkHttpResponse_GetBodySb($this->_cPtr,$sb);
	}

	function GetBodyXml($xml) {
		return CkHttpResponse_GetBodyXml($this->_cPtr,$xml);
	}

	function getCookieDomain($index) {
		return CkHttpResponse_getCookieDomain($this->_cPtr,$index);
	}

	function cookieDomain($index) {
		return CkHttpResponse_cookieDomain($this->_cPtr,$index);
	}

	function getCookieExpiresStr($index) {
		return CkHttpResponse_getCookieExpiresStr($this->_cPtr,$index);
	}

	function cookieExpiresStr($index) {
		return CkHttpResponse_cookieExpiresStr($this->_cPtr,$index);
	}

	function getCookieName($index) {
		return CkHttpResponse_getCookieName($this->_cPtr,$index);
	}

	function cookieName($index) {
		return CkHttpResponse_cookieName($this->_cPtr,$index);
	}

	function getCookiePath($index) {
		return CkHttpResponse_getCookiePath($this->_cPtr,$index);
	}

	function cookiePath($index) {
		return CkHttpResponse_cookiePath($this->_cPtr,$index);
	}

	function getCookieValue($index) {
		return CkHttpResponse_getCookieValue($this->_cPtr,$index);
	}

	function cookieValue($index) {
		return CkHttpResponse_cookieValue($this->_cPtr,$index);
	}

	function getHeaderField($fieldName) {
		return CkHttpResponse_getHeaderField($this->_cPtr,$fieldName);
	}

	function headerField($fieldName) {
		return CkHttpResponse_headerField($this->_cPtr,$fieldName);
	}

	function getHeaderFieldAttr($fieldName,$attrName) {
		return CkHttpResponse_getHeaderFieldAttr($this->_cPtr,$fieldName,$attrName);
	}

	function headerFieldAttr($fieldName,$attrName) {
		return CkHttpResponse_headerFieldAttr($this->_cPtr,$fieldName,$attrName);
	}

	function getHeaderName($index) {
		return CkHttpResponse_getHeaderName($this->_cPtr,$index);
	}

	function headerName($index) {
		return CkHttpResponse_headerName($this->_cPtr,$index);
	}

	function getHeaderValue($index) {
		return CkHttpResponse_getHeaderValue($this->_cPtr,$index);
	}

	function headerValue($index) {
		return CkHttpResponse_headerValue($this->_cPtr,$index);
	}

	function LoadTaskResult($task) {
		return CkHttpResponse_LoadTaskResult($this->_cPtr,$task);
	}

	function SaveBodyBinary($path) {
		return CkHttpResponse_SaveBodyBinary($this->_cPtr,$path);
	}

	function SaveBodyText($bCrlf,$path) {
		return CkHttpResponse_SaveBodyText($this->_cPtr,$bCrlf,$path);
	}

	function urlEncParamValue($encodedParamString,$paramName) {
		return CkHttpResponse_urlEncParamValue($this->_cPtr,$encodedParamString,$paramName);
	}
}

class CkImap {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkImap') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkImap();
	}

	function get_Utf8() {
		return CkImap_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkImap_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkImap_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkImap_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkImap_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_AppendSeen() {
		return CkImap_get_AppendSeen($this->_cPtr);
	}

	function put_AppendSeen($newVal) {
		CkImap_put_AppendSeen($this->_cPtr,$newVal);
	}

	function get_AppendUid() {
		return CkImap_get_AppendUid($this->_cPtr);
	}

	function get_AuthMethod($str) {
		CkImap_get_AuthMethod($this->_cPtr,$str);
	}

	function authMethod() {
		return CkImap_authMethod($this->_cPtr);
	}

	function put_AuthMethod($newVal) {
		CkImap_put_AuthMethod($this->_cPtr,$newVal);
	}

	function get_AuthzId($str) {
		CkImap_get_AuthzId($this->_cPtr,$str);
	}

	function authzId() {
		return CkImap_authzId($this->_cPtr);
	}

	function put_AuthzId($newVal) {
		CkImap_put_AuthzId($this->_cPtr,$newVal);
	}

	function get_AutoDownloadAttachments() {
		return CkImap_get_AutoDownloadAttachments($this->_cPtr);
	}

	function put_AutoDownloadAttachments($newVal) {
		CkImap_put_AutoDownloadAttachments($this->_cPtr,$newVal);
	}

	function get_AutoFix() {
		return CkImap_get_AutoFix($this->_cPtr);
	}

	function put_AutoFix($newVal) {
		CkImap_put_AutoFix($this->_cPtr,$newVal);
	}

	function get_ClientIpAddress($str) {
		CkImap_get_ClientIpAddress($this->_cPtr,$str);
	}

	function clientIpAddress() {
		return CkImap_clientIpAddress($this->_cPtr);
	}

	function put_ClientIpAddress($newVal) {
		CkImap_put_ClientIpAddress($this->_cPtr,$newVal);
	}

	function get_ConnectedToHost($str) {
		CkImap_get_ConnectedToHost($this->_cPtr,$str);
	}

	function connectedToHost() {
		return CkImap_connectedToHost($this->_cPtr);
	}

	function get_ConnectTimeout() {
		return CkImap_get_ConnectTimeout($this->_cPtr);
	}

	function put_ConnectTimeout($newVal) {
		CkImap_put_ConnectTimeout($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkImap_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkImap_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkImap_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Domain($str) {
		CkImap_get_Domain($this->_cPtr,$str);
	}

	function domain() {
		return CkImap_domain($this->_cPtr);
	}

	function put_Domain($newVal) {
		CkImap_put_Domain($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkImap_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkImap_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_HighestModSeq($str) {
		CkImap_get_HighestModSeq($this->_cPtr,$str);
	}

	function highestModSeq() {
		return CkImap_highestModSeq($this->_cPtr);
	}

	function get_HttpProxyAuthMethod($str) {
		CkImap_get_HttpProxyAuthMethod($this->_cPtr,$str);
	}

	function httpProxyAuthMethod() {
		return CkImap_httpProxyAuthMethod($this->_cPtr);
	}

	function put_HttpProxyAuthMethod($newVal) {
		CkImap_put_HttpProxyAuthMethod($this->_cPtr,$newVal);
	}

	function get_HttpProxyDomain($str) {
		CkImap_get_HttpProxyDomain($this->_cPtr,$str);
	}

	function httpProxyDomain() {
		return CkImap_httpProxyDomain($this->_cPtr);
	}

	function put_HttpProxyDomain($newVal) {
		CkImap_put_HttpProxyDomain($this->_cPtr,$newVal);
	}

	function get_HttpProxyHostname($str) {
		CkImap_get_HttpProxyHostname($this->_cPtr,$str);
	}

	function httpProxyHostname() {
		return CkImap_httpProxyHostname($this->_cPtr);
	}

	function put_HttpProxyHostname($newVal) {
		CkImap_put_HttpProxyHostname($this->_cPtr,$newVal);
	}

	function get_HttpProxyPassword($str) {
		CkImap_get_HttpProxyPassword($this->_cPtr,$str);
	}

	function httpProxyPassword() {
		return CkImap_httpProxyPassword($this->_cPtr);
	}

	function put_HttpProxyPassword($newVal) {
		CkImap_put_HttpProxyPassword($this->_cPtr,$newVal);
	}

	function get_HttpProxyPort() {
		return CkImap_get_HttpProxyPort($this->_cPtr);
	}

	function put_HttpProxyPort($newVal) {
		CkImap_put_HttpProxyPort($this->_cPtr,$newVal);
	}

	function get_HttpProxyUsername($str) {
		CkImap_get_HttpProxyUsername($this->_cPtr,$str);
	}

	function httpProxyUsername() {
		return CkImap_httpProxyUsername($this->_cPtr);
	}

	function put_HttpProxyUsername($newVal) {
		CkImap_put_HttpProxyUsername($this->_cPtr,$newVal);
	}

	function get_KeepSessionLog() {
		return CkImap_get_KeepSessionLog($this->_cPtr);
	}

	function put_KeepSessionLog($newVal) {
		CkImap_put_KeepSessionLog($this->_cPtr,$newVal);
	}

	function get_LastAppendedMime($str) {
		CkImap_get_LastAppendedMime($this->_cPtr,$str);
	}

	function lastAppendedMime() {
		return CkImap_lastAppendedMime($this->_cPtr);
	}

	function get_LastCommand($str) {
		CkImap_get_LastCommand($this->_cPtr,$str);
	}

	function lastCommand() {
		return CkImap_lastCommand($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkImap_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkImap_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkImap_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkImap_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkImap_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkImap_lastErrorXml($this->_cPtr);
	}

	function get_LastIntermediateResponse($str) {
		CkImap_get_LastIntermediateResponse($this->_cPtr,$str);
	}

	function lastIntermediateResponse() {
		return CkImap_lastIntermediateResponse($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkImap_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkImap_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LastResponse($str) {
		CkImap_get_LastResponse($this->_cPtr,$str);
	}

	function lastResponse() {
		return CkImap_lastResponse($this->_cPtr);
	}

	function get_LastResponseCode($str) {
		CkImap_get_LastResponseCode($this->_cPtr,$str);
	}

	function lastResponseCode() {
		return CkImap_lastResponseCode($this->_cPtr);
	}

	function get_LoggedInUser($str) {
		CkImap_get_LoggedInUser($this->_cPtr,$str);
	}

	function loggedInUser() {
		return CkImap_loggedInUser($this->_cPtr);
	}

	function get_NumMessages() {
		return CkImap_get_NumMessages($this->_cPtr);
	}

	function get_PeekMode() {
		return CkImap_get_PeekMode($this->_cPtr);
	}

	function put_PeekMode($newVal) {
		CkImap_put_PeekMode($this->_cPtr,$newVal);
	}

	function get_PercentDoneScale() {
		return CkImap_get_PercentDoneScale($this->_cPtr);
	}

	function put_PercentDoneScale($newVal) {
		CkImap_put_PercentDoneScale($this->_cPtr,$newVal);
	}

	function get_Port() {
		return CkImap_get_Port($this->_cPtr);
	}

	function put_Port($newVal) {
		CkImap_put_Port($this->_cPtr,$newVal);
	}

	function get_PreferIpv6() {
		return CkImap_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkImap_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_ReadTimeout() {
		return CkImap_get_ReadTimeout($this->_cPtr);
	}

	function put_ReadTimeout($newVal) {
		CkImap_put_ReadTimeout($this->_cPtr,$newVal);
	}

	function get_RequireSslCertVerify() {
		return CkImap_get_RequireSslCertVerify($this->_cPtr);
	}

	function put_RequireSslCertVerify($newVal) {
		CkImap_put_RequireSslCertVerify($this->_cPtr,$newVal);
	}

	function get_SearchCharset($str) {
		CkImap_get_SearchCharset($this->_cPtr,$str);
	}

	function searchCharset() {
		return CkImap_searchCharset($this->_cPtr);
	}

	function put_SearchCharset($newVal) {
		CkImap_put_SearchCharset($this->_cPtr,$newVal);
	}

	function get_SelectedMailbox($str) {
		CkImap_get_SelectedMailbox($this->_cPtr,$str);
	}

	function selectedMailbox() {
		return CkImap_selectedMailbox($this->_cPtr);
	}

	function get_SendBufferSize() {
		return CkImap_get_SendBufferSize($this->_cPtr);
	}

	function put_SendBufferSize($newVal) {
		CkImap_put_SendBufferSize($this->_cPtr,$newVal);
	}

	function get_SeparatorChar($str) {
		CkImap_get_SeparatorChar($this->_cPtr,$str);
	}

	function separatorChar() {
		return CkImap_separatorChar($this->_cPtr);
	}

	function put_SeparatorChar($newVal) {
		CkImap_put_SeparatorChar($this->_cPtr,$newVal);
	}

	function get_SessionLog($str) {
		CkImap_get_SessionLog($this->_cPtr,$str);
	}

	function sessionLog() {
		return CkImap_sessionLog($this->_cPtr);
	}

	function get_SocksHostname($str) {
		CkImap_get_SocksHostname($this->_cPtr,$str);
	}

	function socksHostname() {
		return CkImap_socksHostname($this->_cPtr);
	}

	function put_SocksHostname($newVal) {
		CkImap_put_SocksHostname($this->_cPtr,$newVal);
	}

	function get_SocksPassword($str) {
		CkImap_get_SocksPassword($this->_cPtr,$str);
	}

	function socksPassword() {
		return CkImap_socksPassword($this->_cPtr);
	}

	function put_SocksPassword($newVal) {
		CkImap_put_SocksPassword($this->_cPtr,$newVal);
	}

	function get_SocksPort() {
		return CkImap_get_SocksPort($this->_cPtr);
	}

	function put_SocksPort($newVal) {
		CkImap_put_SocksPort($this->_cPtr,$newVal);
	}

	function get_SocksUsername($str) {
		CkImap_get_SocksUsername($this->_cPtr,$str);
	}

	function socksUsername() {
		return CkImap_socksUsername($this->_cPtr);
	}

	function put_SocksUsername($newVal) {
		CkImap_put_SocksUsername($this->_cPtr,$newVal);
	}

	function get_SocksVersion() {
		return CkImap_get_SocksVersion($this->_cPtr);
	}

	function put_SocksVersion($newVal) {
		CkImap_put_SocksVersion($this->_cPtr,$newVal);
	}

	function get_SoRcvBuf() {
		return CkImap_get_SoRcvBuf($this->_cPtr);
	}

	function put_SoRcvBuf($newVal) {
		CkImap_put_SoRcvBuf($this->_cPtr,$newVal);
	}

	function get_SortCriteria($str) {
		CkImap_get_SortCriteria($this->_cPtr,$str);
	}

	function sortCriteria() {
		return CkImap_sortCriteria($this->_cPtr);
	}

	function put_SortCriteria($newVal) {
		CkImap_put_SortCriteria($this->_cPtr,$newVal);
	}

	function get_SoSndBuf() {
		return CkImap_get_SoSndBuf($this->_cPtr);
	}

	function put_SoSndBuf($newVal) {
		CkImap_put_SoSndBuf($this->_cPtr,$newVal);
	}

	function get_Ssl() {
		return CkImap_get_Ssl($this->_cPtr);
	}

	function put_Ssl($newVal) {
		CkImap_put_Ssl($this->_cPtr,$newVal);
	}

	function get_SslAllowedCiphers($str) {
		CkImap_get_SslAllowedCiphers($this->_cPtr,$str);
	}

	function sslAllowedCiphers() {
		return CkImap_sslAllowedCiphers($this->_cPtr);
	}

	function put_SslAllowedCiphers($newVal) {
		CkImap_put_SslAllowedCiphers($this->_cPtr,$newVal);
	}

	function get_SslProtocol($str) {
		CkImap_get_SslProtocol($this->_cPtr,$str);
	}

	function sslProtocol() {
		return CkImap_sslProtocol($this->_cPtr);
	}

	function put_SslProtocol($newVal) {
		CkImap_put_SslProtocol($this->_cPtr,$newVal);
	}

	function get_SslServerCertVerified() {
		return CkImap_get_SslServerCertVerified($this->_cPtr);
	}

	function get_StartTls() {
		return CkImap_get_StartTls($this->_cPtr);
	}

	function put_StartTls($newVal) {
		CkImap_put_StartTls($this->_cPtr,$newVal);
	}

	function get_TlsCipherSuite($str) {
		CkImap_get_TlsCipherSuite($this->_cPtr,$str);
	}

	function tlsCipherSuite() {
		return CkImap_tlsCipherSuite($this->_cPtr);
	}

	function get_TlsPinSet($str) {
		CkImap_get_TlsPinSet($this->_cPtr,$str);
	}

	function tlsPinSet() {
		return CkImap_tlsPinSet($this->_cPtr);
	}

	function put_TlsPinSet($newVal) {
		CkImap_put_TlsPinSet($this->_cPtr,$newVal);
	}

	function get_TlsVersion($str) {
		CkImap_get_TlsVersion($this->_cPtr,$str);
	}

	function tlsVersion() {
		return CkImap_tlsVersion($this->_cPtr);
	}

	function get_UidNext() {
		return CkImap_get_UidNext($this->_cPtr);
	}

	function get_UidValidity() {
		return CkImap_get_UidValidity($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkImap_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkImap_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkImap_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkImap_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkImap_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkImap_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkImap_version($this->_cPtr);
	}

	function AddPfxSourceBd($bd,$password) {
		return CkImap_AddPfxSourceBd($this->_cPtr,$bd,$password);
	}

	function AddPfxSourceData($pfxBytes,$pfxPassword) {
		return CkImap_AddPfxSourceData($this->_cPtr,$pfxBytes,$pfxPassword);
	}

	function AddPfxSourceFile($pfxFilePath,$pfxPassword) {
		return CkImap_AddPfxSourceFile($this->_cPtr,$pfxFilePath,$pfxPassword);
	}

	function AppendMail($mailbox,$email) {
		return CkImap_AppendMail($this->_cPtr,$mailbox,$email);
	}

	function AppendMailAsync($mailbox,$email) {
		$r=CkImap_AppendMailAsync($this->_cPtr,$mailbox,$email);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendMime($mailbox,$mimeText) {
		return CkImap_AppendMime($this->_cPtr,$mailbox,$mimeText);
	}

	function AppendMimeAsync($mailbox,$mimeText) {
		$r=CkImap_AppendMimeAsync($this->_cPtr,$mailbox,$mimeText);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendMimeWithDateStr($mailbox,$mimeText,$internalDateStr) {
		return CkImap_AppendMimeWithDateStr($this->_cPtr,$mailbox,$mimeText,$internalDateStr);
	}

	function AppendMimeWithDateStrAsync($mailbox,$mimeText,$internalDateStr) {
		$r=CkImap_AppendMimeWithDateStrAsync($this->_cPtr,$mailbox,$mimeText,$internalDateStr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendMimeWithFlags($mailbox,$mimeText,$seen,$flagged,$answered,$draft) {
		return CkImap_AppendMimeWithFlags($this->_cPtr,$mailbox,$mimeText,$seen,$flagged,$answered,$draft);
	}

	function AppendMimeWithFlagsAsync($mailbox,$mimeText,$seen,$flagged,$answered,$draft) {
		$r=CkImap_AppendMimeWithFlagsAsync($this->_cPtr,$mailbox,$mimeText,$seen,$flagged,$answered,$draft);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendMimeWithFlagsSb($mailbox,$sbMime,$seen,$flagged,$answered,$draft) {
		return CkImap_AppendMimeWithFlagsSb($this->_cPtr,$mailbox,$sbMime,$seen,$flagged,$answered,$draft);
	}

	function AppendMimeWithFlagsSbAsync($mailbox,$sbMime,$seen,$flagged,$answered,$draft) {
		$r=CkImap_AppendMimeWithFlagsSbAsync($this->_cPtr,$mailbox,$sbMime,$seen,$flagged,$answered,$draft);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function capability() {
		return CkImap_capability($this->_cPtr);
	}

	function CapabilityAsync() {
		$r=CkImap_CapabilityAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CheckConnection() {
		return CkImap_CheckConnection($this->_cPtr);
	}

	function CheckForNewEmail() {
		$r=CkImap_CheckForNewEmail($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkMessageSet($r);
		}
		return $r;
	}

	function CheckForNewEmailAsync() {
		$r=CkImap_CheckForNewEmailAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ClearSessionLog() {
		CkImap_ClearSessionLog($this->_cPtr);
	}

	function CloseMailbox($mailbox) {
		return CkImap_CloseMailbox($this->_cPtr,$mailbox);
	}

	function CloseMailboxAsync($mailbox) {
		$r=CkImap_CloseMailboxAsync($this->_cPtr,$mailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Connect($domainName) {
		return CkImap_Connect($this->_cPtr,$domainName);
	}

	function ConnectAsync($domainName) {
		$r=CkImap_ConnectAsync($this->_cPtr,$domainName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Copy($msgId,$bUid,$copyToMailbox) {
		return CkImap_Copy($this->_cPtr,$msgId,$bUid,$copyToMailbox);
	}

	function CopyAsync($msgId,$bUid,$copyToMailbox) {
		$r=CkImap_CopyAsync($this->_cPtr,$msgId,$bUid,$copyToMailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CopyMultiple($messageSet,$copyToMailbox) {
		return CkImap_CopyMultiple($this->_cPtr,$messageSet,$copyToMailbox);
	}

	function CopyMultipleAsync($messageSet,$copyToMailbox) {
		$r=CkImap_CopyMultipleAsync($this->_cPtr,$messageSet,$copyToMailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CopySequence($startSeqNum,$count,$copyToMailbox) {
		return CkImap_CopySequence($this->_cPtr,$startSeqNum,$count,$copyToMailbox);
	}

	function CopySequenceAsync($startSeqNum,$count,$copyToMailbox) {
		$r=CkImap_CopySequenceAsync($this->_cPtr,$startSeqNum,$count,$copyToMailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CreateMailbox($mailbox) {
		return CkImap_CreateMailbox($this->_cPtr,$mailbox);
	}

	function CreateMailboxAsync($mailbox) {
		$r=CkImap_CreateMailboxAsync($this->_cPtr,$mailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteMailbox($mailbox) {
		return CkImap_DeleteMailbox($this->_cPtr,$mailbox);
	}

	function DeleteMailboxAsync($mailbox) {
		$r=CkImap_DeleteMailboxAsync($this->_cPtr,$mailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Disconnect() {
		return CkImap_Disconnect($this->_cPtr);
	}

	function DisconnectAsync() {
		$r=CkImap_DisconnectAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ExamineMailbox($mailbox) {
		return CkImap_ExamineMailbox($this->_cPtr,$mailbox);
	}

	function ExamineMailboxAsync($mailbox) {
		$r=CkImap_ExamineMailboxAsync($this->_cPtr,$mailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Expunge() {
		return CkImap_Expunge($this->_cPtr);
	}

	function ExpungeAsync() {
		$r=CkImap_ExpungeAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ExpungeAndClose() {
		return CkImap_ExpungeAndClose($this->_cPtr);
	}

	function ExpungeAndCloseAsync() {
		$r=CkImap_ExpungeAndCloseAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchAttachment($emailObject,$attachmentIndex,$saveToPath) {
		return CkImap_FetchAttachment($this->_cPtr,$emailObject,$attachmentIndex,$saveToPath);
	}

	function FetchAttachmentAsync($emailObject,$attachmentIndex,$saveToPath) {
		$r=CkImap_FetchAttachmentAsync($this->_cPtr,$emailObject,$attachmentIndex,$saveToPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchAttachmentBd($email,$attachmentIndex,$binData) {
		return CkImap_FetchAttachmentBd($this->_cPtr,$email,$attachmentIndex,$binData);
	}

	function FetchAttachmentBdAsync($email,$attachmentIndex,$binData) {
		$r=CkImap_FetchAttachmentBdAsync($this->_cPtr,$email,$attachmentIndex,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchAttachmentBytes($email,$attachIndex,$outBytes) {
		return CkImap_FetchAttachmentBytes($this->_cPtr,$email,$attachIndex,$outBytes);
	}

	function FetchAttachmentBytesAsync($email,$attachIndex) {
		$r=CkImap_FetchAttachmentBytesAsync($this->_cPtr,$email,$attachIndex);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchAttachmentSb($email,$attachmentIndex,$charset,$sb) {
		return CkImap_FetchAttachmentSb($this->_cPtr,$email,$attachmentIndex,$charset,$sb);
	}

	function FetchAttachmentSbAsync($email,$attachmentIndex,$charset,$sb) {
		$r=CkImap_FetchAttachmentSbAsync($this->_cPtr,$email,$attachmentIndex,$charset,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fetchAttachmentString($emailObject,$attachmentIndex,$charset) {
		return CkImap_fetchAttachmentString($this->_cPtr,$emailObject,$attachmentIndex,$charset);
	}

	function FetchAttachmentStringAsync($emailObject,$attachmentIndex,$charset) {
		$r=CkImap_FetchAttachmentStringAsync($this->_cPtr,$emailObject,$attachmentIndex,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchBundle($messageSet) {
		$r=CkImap_FetchBundle($this->_cPtr,$messageSet);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function FetchBundleAsync($messageSet) {
		$r=CkImap_FetchBundleAsync($this->_cPtr,$messageSet);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchBundleAsMime($messageSet) {
		$r=CkImap_FetchBundleAsMime($this->_cPtr,$messageSet);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function FetchBundleAsMimeAsync($messageSet) {
		$r=CkImap_FetchBundleAsMimeAsync($this->_cPtr,$messageSet);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchChunk($startSeqNum,$count,$failedSet,$fetchedSet) {
		$r=CkImap_FetchChunk($this->_cPtr,$startSeqNum,$count,$failedSet,$fetchedSet);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function FetchChunkAsync($startSeqNum,$count,$failedSet,$fetchedSet) {
		$r=CkImap_FetchChunkAsync($this->_cPtr,$startSeqNum,$count,$failedSet,$fetchedSet);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchChunk2($seqnum,$count,$failedSet,$fetchedSet,$bundle) {
		return CkImap_FetchChunk2($this->_cPtr,$seqnum,$count,$failedSet,$fetchedSet,$bundle);
	}

	function FetchChunk2Async($seqnum,$count,$failedSet,$fetchedSet,$bundle) {
		$r=CkImap_FetchChunk2Async($this->_cPtr,$seqnum,$count,$failedSet,$fetchedSet,$bundle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchEmail($headerOnly,$msgId,$bUid,$email) {
		return CkImap_FetchEmail($this->_cPtr,$headerOnly,$msgId,$bUid,$email);
	}

	function FetchEmailAsync($headerOnly,$msgId,$bUid,$email) {
		$r=CkImap_FetchEmailAsync($this->_cPtr,$headerOnly,$msgId,$bUid,$email);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fetchFlags($msgId,$bUid) {
		return CkImap_fetchFlags($this->_cPtr,$msgId,$bUid);
	}

	function FetchFlagsAsync($msgId,$bUid) {
		$r=CkImap_FetchFlagsAsync($this->_cPtr,$msgId,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchHeaders($messageSet) {
		$r=CkImap_FetchHeaders($this->_cPtr,$messageSet);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function FetchHeadersAsync($messageSet) {
		$r=CkImap_FetchHeadersAsync($this->_cPtr,$messageSet);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchMsgSet($headersOnly,$msgSet,$bundle) {
		return CkImap_FetchMsgSet($this->_cPtr,$headersOnly,$msgSet,$bundle);
	}

	function FetchMsgSetAsync($headersOnly,$msgSet,$bundle) {
		$r=CkImap_FetchMsgSetAsync($this->_cPtr,$headersOnly,$msgSet,$bundle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchRange($headersOnly,$seqnum,$count,$bundle) {
		return CkImap_FetchRange($this->_cPtr,$headersOnly,$seqnum,$count,$bundle);
	}

	function FetchRangeAsync($headersOnly,$seqnum,$count,$bundle) {
		$r=CkImap_FetchRangeAsync($this->_cPtr,$headersOnly,$seqnum,$count,$bundle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchSequence($startSeqNum,$numMessages) {
		$r=CkImap_FetchSequence($this->_cPtr,$startSeqNum,$numMessages);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function FetchSequenceAsync($startSeqNum,$numMessages) {
		$r=CkImap_FetchSequenceAsync($this->_cPtr,$startSeqNum,$numMessages);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchSequenceAsMime($startSeqNum,$numMessages) {
		$r=CkImap_FetchSequenceAsMime($this->_cPtr,$startSeqNum,$numMessages);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function FetchSequenceAsMimeAsync($startSeqNum,$numMessages) {
		$r=CkImap_FetchSequenceAsMimeAsync($this->_cPtr,$startSeqNum,$numMessages);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchSequenceHeaders($startSeqNum,$numMessages) {
		$r=CkImap_FetchSequenceHeaders($this->_cPtr,$startSeqNum,$numMessages);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function FetchSequenceHeadersAsync($startSeqNum,$numMessages) {
		$r=CkImap_FetchSequenceHeadersAsync($this->_cPtr,$startSeqNum,$numMessages);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchSingle($msgId,$bUid) {
		$r=CkImap_FetchSingle($this->_cPtr,$msgId,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function FetchSingleAsync($msgId,$bUid) {
		$r=CkImap_FetchSingleAsync($this->_cPtr,$msgId,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fetchSingleAsMime($msgId,$bUid) {
		return CkImap_fetchSingleAsMime($this->_cPtr,$msgId,$bUid);
	}

	function FetchSingleAsMimeAsync($msgId,$bUid) {
		$r=CkImap_FetchSingleAsMimeAsync($this->_cPtr,$msgId,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchSingleAsMimeSb($msgId,$bUid,$sbMime) {
		return CkImap_FetchSingleAsMimeSb($this->_cPtr,$msgId,$bUid,$sbMime);
	}

	function FetchSingleAsMimeSbAsync($msgId,$bUid,$sbMime) {
		$r=CkImap_FetchSingleAsMimeSbAsync($this->_cPtr,$msgId,$bUid,$sbMime);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchSingleBd($msgId,$bUid,$mimeData) {
		return CkImap_FetchSingleBd($this->_cPtr,$msgId,$bUid,$mimeData);
	}

	function FetchSingleBdAsync($msgId,$bUid,$mimeData) {
		$r=CkImap_FetchSingleBdAsync($this->_cPtr,$msgId,$bUid,$mimeData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchSingleHeader($msgId,$bUid) {
		$r=CkImap_FetchSingleHeader($this->_cPtr,$msgId,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function FetchSingleHeaderAsync($msgId,$bUid) {
		$r=CkImap_FetchSingleHeaderAsync($this->_cPtr,$msgId,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fetchSingleHeaderAsMime($msgId,$bUID) {
		return CkImap_fetchSingleHeaderAsMime($this->_cPtr,$msgId,$bUID);
	}

	function FetchSingleHeaderAsMimeAsync($msgId,$bUID) {
		$r=CkImap_FetchSingleHeaderAsMimeAsync($this->_cPtr,$msgId,$bUID);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetAllUids() {
		$r=CkImap_GetAllUids($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkMessageSet($r);
		}
		return $r;
	}

	function GetAllUidsAsync() {
		$r=CkImap_GetAllUidsAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getMailAttachFilename($email,$attachIndex) {
		return CkImap_getMailAttachFilename($this->_cPtr,$email,$attachIndex);
	}

	function mailAttachFilename($email,$attachIndex) {
		return CkImap_mailAttachFilename($this->_cPtr,$email,$attachIndex);
	}

	function GetMailAttachSize($email,$attachIndex) {
		return CkImap_GetMailAttachSize($this->_cPtr,$email,$attachIndex);
	}

	function getMailboxStatus($mailbox) {
		return CkImap_getMailboxStatus($this->_cPtr,$mailbox);
	}

	function mailboxStatus($mailbox) {
		return CkImap_mailboxStatus($this->_cPtr,$mailbox);
	}

	function GetMailboxStatusAsync($mailbox) {
		$r=CkImap_GetMailboxStatusAsync($this->_cPtr,$mailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetMailFlag($email,$flagName) {
		return CkImap_GetMailFlag($this->_cPtr,$email,$flagName);
	}

	function GetMailNumAttach($email) {
		return CkImap_GetMailNumAttach($this->_cPtr,$email);
	}

	function GetMailSize($email) {
		return CkImap_GetMailSize($this->_cPtr,$email);
	}

	function getQuota($quotaRoot) {
		return CkImap_getQuota($this->_cPtr,$quotaRoot);
	}

	function quota($quotaRoot) {
		return CkImap_quota($this->_cPtr,$quotaRoot);
	}

	function GetQuotaAsync($quotaRoot) {
		$r=CkImap_GetQuotaAsync($this->_cPtr,$quotaRoot);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getQuotaRoot($mailboxName) {
		return CkImap_getQuotaRoot($this->_cPtr,$mailboxName);
	}

	function quotaRoot($mailboxName) {
		return CkImap_quotaRoot($this->_cPtr,$mailboxName);
	}

	function GetQuotaRootAsync($mailboxName) {
		$r=CkImap_GetQuotaRootAsync($this->_cPtr,$mailboxName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetServerCert($cert) {
		return CkImap_GetServerCert($this->_cPtr,$cert);
	}

	function GetSslServerCert() {
		$r=CkImap_GetSslServerCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function HasCapability($name,$capabilityResponse) {
		return CkImap_HasCapability($this->_cPtr,$name,$capabilityResponse);
	}

	function idleCheck($timeoutMs) {
		return CkImap_idleCheck($this->_cPtr,$timeoutMs);
	}

	function IdleCheckAsync($timeoutMs) {
		$r=CkImap_IdleCheckAsync($this->_cPtr,$timeoutMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function IdleDone() {
		return CkImap_IdleDone($this->_cPtr);
	}

	function IdleDoneAsync() {
		$r=CkImap_IdleDoneAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function IdleStart() {
		return CkImap_IdleStart($this->_cPtr);
	}

	function IdleStartAsync() {
		$r=CkImap_IdleStartAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function IsConnected() {
		return CkImap_IsConnected($this->_cPtr);
	}

	function IsLoggedIn() {
		return CkImap_IsLoggedIn($this->_cPtr);
	}

	function ListMailboxes($reference,$wildcardedMailbox) {
		$r=CkImap_ListMailboxes($this->_cPtr,$reference,$wildcardedMailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkMailboxes($r);
		}
		return $r;
	}

	function ListMailboxesAsync($reference,$wildcardedMailbox) {
		$r=CkImap_ListMailboxesAsync($this->_cPtr,$reference,$wildcardedMailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ListSubscribed($reference,$wildcardedMailbox) {
		$r=CkImap_ListSubscribed($this->_cPtr,$reference,$wildcardedMailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkMailboxes($r);
		}
		return $r;
	}

	function ListSubscribedAsync($reference,$wildcardedMailbox) {
		$r=CkImap_ListSubscribedAsync($this->_cPtr,$reference,$wildcardedMailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkImap_LoadTaskCaller($this->_cPtr,$task);
	}

	function Login($loginName,$password) {
		return CkImap_Login($this->_cPtr,$loginName,$password);
	}

	function LoginAsync($loginName,$password) {
		$r=CkImap_LoginAsync($this->_cPtr,$loginName,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LoginSecure($loginName,$password) {
		return CkImap_LoginSecure($this->_cPtr,$loginName,$password);
	}

	function LoginSecureAsync($loginName,$password) {
		$r=CkImap_LoginSecureAsync($this->_cPtr,$loginName,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Logout() {
		return CkImap_Logout($this->_cPtr);
	}

	function LogoutAsync() {
		$r=CkImap_LogoutAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function MbxList($subscribed,$reference,$mbxPattern,$mboxes) {
		return CkImap_MbxList($this->_cPtr,$subscribed,$reference,$mbxPattern,$mboxes);
	}

	function MbxListAsync($subscribed,$reference,$mbxPattern,$mboxes) {
		$r=CkImap_MbxListAsync($this->_cPtr,$subscribed,$reference,$mbxPattern,$mboxes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function MoveMessages($messageSet,$destFolder) {
		return CkImap_MoveMessages($this->_cPtr,$messageSet,$destFolder);
	}

	function MoveMessagesAsync($messageSet,$destFolder) {
		$r=CkImap_MoveMessagesAsync($this->_cPtr,$messageSet,$destFolder);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Noop() {
		return CkImap_Noop($this->_cPtr);
	}

	function NoopAsync() {
		$r=CkImap_NoopAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QueryMbx($criteria,$bUid,$msgSet) {
		return CkImap_QueryMbx($this->_cPtr,$criteria,$bUid,$msgSet);
	}

	function QueryMbxAsync($criteria,$bUid,$msgSet) {
		$r=CkImap_QueryMbxAsync($this->_cPtr,$criteria,$bUid,$msgSet);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QueryThread($threadAlg,$searchCriteria,$bUid,$json) {
		return CkImap_QueryThread($this->_cPtr,$threadAlg,$searchCriteria,$bUid,$json);
	}

	function QueryThreadAsync($threadAlg,$searchCriteria,$bUid,$json) {
		$r=CkImap_QueryThreadAsync($this->_cPtr,$threadAlg,$searchCriteria,$bUid,$json);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RawCommandBd($bdCmd,$bdResp) {
		return CkImap_RawCommandBd($this->_cPtr,$bdCmd,$bdResp);
	}

	function RawCommandBdAsync($bdCmd,$bdResp) {
		$r=CkImap_RawCommandBdAsync($this->_cPtr,$bdCmd,$bdResp);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RefetchMailFlags($email) {
		return CkImap_RefetchMailFlags($this->_cPtr,$email);
	}

	function RefetchMailFlagsAsync($email) {
		$r=CkImap_RefetchMailFlagsAsync($this->_cPtr,$email);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RenameMailbox($fromMailbox,$toMailbox) {
		return CkImap_RenameMailbox($this->_cPtr,$fromMailbox,$toMailbox);
	}

	function RenameMailboxAsync($fromMailbox,$toMailbox) {
		$r=CkImap_RenameMailboxAsync($this->_cPtr,$fromMailbox,$toMailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Search($criteria,$bUid) {
		$r=CkImap_Search($this->_cPtr,$criteria,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkMessageSet($r);
		}
		return $r;
	}

	function SearchAsync($criteria,$bUid) {
		$r=CkImap_SearchAsync($this->_cPtr,$criteria,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SelectMailbox($mailbox) {
		return CkImap_SelectMailbox($this->_cPtr,$mailbox);
	}

	function SelectMailboxAsync($mailbox) {
		$r=CkImap_SelectMailboxAsync($this->_cPtr,$mailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function sendRawCommand($cmd) {
		return CkImap_sendRawCommand($this->_cPtr,$cmd);
	}

	function SendRawCommandAsync($cmd) {
		$r=CkImap_SendRawCommandAsync($this->_cPtr,$cmd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendRawCommandB($cmd,$outBytes) {
		return CkImap_SendRawCommandB($this->_cPtr,$cmd,$outBytes);
	}

	function SendRawCommandBAsync($cmd) {
		$r=CkImap_SendRawCommandBAsync($this->_cPtr,$cmd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendRawCommandC($cmd,$outBytes) {
		return CkImap_SendRawCommandC($this->_cPtr,$cmd,$outBytes);
	}

	function SendRawCommandCAsync($cmd) {
		$r=CkImap_SendRawCommandCAsync($this->_cPtr,$cmd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetDecryptCert($cert) {
		return CkImap_SetDecryptCert($this->_cPtr,$cert);
	}

	function SetDecryptCert2($cert,$key) {
		return CkImap_SetDecryptCert2($this->_cPtr,$cert,$key);
	}

	function SetFlag($msgId,$bUid,$flagName,$value) {
		return CkImap_SetFlag($this->_cPtr,$msgId,$bUid,$flagName,$value);
	}

	function SetFlagAsync($msgId,$bUid,$flagName,$value) {
		$r=CkImap_SetFlagAsync($this->_cPtr,$msgId,$bUid,$flagName,$value);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetFlags($messageSet,$flagName,$value) {
		return CkImap_SetFlags($this->_cPtr,$messageSet,$flagName,$value);
	}

	function SetFlagsAsync($messageSet,$flagName,$value) {
		$r=CkImap_SetFlagsAsync($this->_cPtr,$messageSet,$flagName,$value);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetMailFlag($email,$flagName,$value) {
		return CkImap_SetMailFlag($this->_cPtr,$email,$flagName,$value);
	}

	function SetMailFlagAsync($email,$flagName,$value) {
		$r=CkImap_SetMailFlagAsync($this->_cPtr,$email,$flagName,$value);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetQuota($quotaRoot,$resource,$quota) {
		return CkImap_SetQuota($this->_cPtr,$quotaRoot,$resource,$quota);
	}

	function SetQuotaAsync($quotaRoot,$resource,$quota) {
		$r=CkImap_SetQuotaAsync($this->_cPtr,$quotaRoot,$resource,$quota);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetSslClientCert($cert) {
		return CkImap_SetSslClientCert($this->_cPtr,$cert);
	}

	function SetSslClientCertPem($pemDataOrFilename,$pemPassword) {
		return CkImap_SetSslClientCertPem($this->_cPtr,$pemDataOrFilename,$pemPassword);
	}

	function SetSslClientCertPfx($pfxFilename,$pfxPassword) {
		return CkImap_SetSslClientCertPfx($this->_cPtr,$pfxFilename,$pfxPassword);
	}

	function Sort($sortCriteria,$charset,$searchCriteria,$bUid) {
		$r=CkImap_Sort($this->_cPtr,$sortCriteria,$charset,$searchCriteria,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkMessageSet($r);
		}
		return $r;
	}

	function SortAsync($sortCriteria,$charset,$searchCriteria,$bUid) {
		$r=CkImap_SortAsync($this->_cPtr,$sortCriteria,$charset,$searchCriteria,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshAuthenticatePk($sshLogin,$privateKey) {
		return CkImap_SshAuthenticatePk($this->_cPtr,$sshLogin,$privateKey);
	}

	function SshAuthenticatePkAsync($sshLogin,$privateKey) {
		$r=CkImap_SshAuthenticatePkAsync($this->_cPtr,$sshLogin,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshAuthenticatePw($sshLogin,$sshPassword) {
		return CkImap_SshAuthenticatePw($this->_cPtr,$sshLogin,$sshPassword);
	}

	function SshAuthenticatePwAsync($sshLogin,$sshPassword) {
		$r=CkImap_SshAuthenticatePwAsync($this->_cPtr,$sshLogin,$sshPassword);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshCloseTunnel() {
		return CkImap_SshCloseTunnel($this->_cPtr);
	}

	function SshCloseTunnelAsync() {
		$r=CkImap_SshCloseTunnelAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshOpenTunnel($sshHostname,$sshPort) {
		return CkImap_SshOpenTunnel($this->_cPtr,$sshHostname,$sshPort);
	}

	function SshOpenTunnelAsync($sshHostname,$sshPort) {
		$r=CkImap_SshOpenTunnelAsync($this->_cPtr,$sshHostname,$sshPort);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function StoreFlags($msgId,$bUid,$flagNames,$value) {
		return CkImap_StoreFlags($this->_cPtr,$msgId,$bUid,$flagNames,$value);
	}

	function StoreFlagsAsync($msgId,$bUid,$flagNames,$value) {
		$r=CkImap_StoreFlagsAsync($this->_cPtr,$msgId,$bUid,$flagNames,$value);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Subscribe($mailbox) {
		return CkImap_Subscribe($this->_cPtr,$mailbox);
	}

	function SubscribeAsync($mailbox) {
		$r=CkImap_SubscribeAsync($this->_cPtr,$mailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ThreadCmd($threadAlg,$charset,$searchCriteria,$bUid) {
		$r=CkImap_ThreadCmd($this->_cPtr,$threadAlg,$charset,$searchCriteria,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function ThreadCmdAsync($threadAlg,$charset,$searchCriteria,$bUid) {
		$r=CkImap_ThreadCmdAsync($this->_cPtr,$threadAlg,$charset,$searchCriteria,$bUid);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Unsubscribe($mailbox) {
		return CkImap_Unsubscribe($this->_cPtr,$mailbox);
	}

	function UnsubscribeAsync($mailbox) {
		$r=CkImap_UnsubscribeAsync($this->_cPtr,$mailbox);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UseCertVault($vault) {
		return CkImap_UseCertVault($this->_cPtr,$vault);
	}

	function UseSsh($ssh) {
		return CkImap_UseSsh($this->_cPtr,$ssh);
	}

	function UseSshTunnel($tunnel) {
		return CkImap_UseSshTunnel($this->_cPtr,$tunnel);
	}
}

class CkJavaKeyStore {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkJavaKeyStore') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkJavaKeyStore();
	}

	function get_Utf8() {
		return CkJavaKeyStore_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkJavaKeyStore_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkJavaKeyStore_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkJavaKeyStore_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkJavaKeyStore_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkJavaKeyStore_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkJavaKeyStore_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkJavaKeyStore_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkJavaKeyStore_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkJavaKeyStore_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkJavaKeyStore_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkJavaKeyStore_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkJavaKeyStore_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumPrivateKeys() {
		return CkJavaKeyStore_get_NumPrivateKeys($this->_cPtr);
	}

	function get_NumSecretKeys() {
		return CkJavaKeyStore_get_NumSecretKeys($this->_cPtr);
	}

	function get_NumTrustedCerts() {
		return CkJavaKeyStore_get_NumTrustedCerts($this->_cPtr);
	}

	function get_RequireCompleteChain() {
		return CkJavaKeyStore_get_RequireCompleteChain($this->_cPtr);
	}

	function put_RequireCompleteChain($newVal) {
		CkJavaKeyStore_put_RequireCompleteChain($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkJavaKeyStore_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkJavaKeyStore_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_VerifyKeyedDigest() {
		return CkJavaKeyStore_get_VerifyKeyedDigest($this->_cPtr);
	}

	function put_VerifyKeyedDigest($newVal) {
		CkJavaKeyStore_put_VerifyKeyedDigest($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkJavaKeyStore_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkJavaKeyStore_version($this->_cPtr);
	}

	function AddPfx($pfx,$alias,$password) {
		return CkJavaKeyStore_AddPfx($this->_cPtr,$pfx,$alias,$password);
	}

	function AddPrivateKey($cert,$alias,$password) {
		return CkJavaKeyStore_AddPrivateKey($this->_cPtr,$cert,$alias,$password);
	}

	function AddSecretKey($encodedKeyBytes,$encoding,$algorithm,$alias,$password) {
		return CkJavaKeyStore_AddSecretKey($this->_cPtr,$encodedKeyBytes,$encoding,$algorithm,$alias,$password);
	}

	function AddTrustedCert($cert,$alias) {
		return CkJavaKeyStore_AddTrustedCert($this->_cPtr,$cert,$alias);
	}

	function CertChainAt($index,$certChain) {
		return CkJavaKeyStore_CertChainAt($this->_cPtr,$index,$certChain);
	}

	function CertChainOf($alias,$caseSensitive,$certChain) {
		return CkJavaKeyStore_CertChainOf($this->_cPtr,$alias,$caseSensitive,$certChain);
	}

	function ChangePassword($index,$oldPassword,$newPassword) {
		return CkJavaKeyStore_ChangePassword($this->_cPtr,$index,$oldPassword,$newPassword);
	}

	function FindCertChain($alias,$caseSensitive) {
		$r=CkJavaKeyStore_FindCertChain($this->_cPtr,$alias,$caseSensitive);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCertChain($r);
		}
		return $r;
	}

	function FindPrivateKey($password,$alias,$caseSensitive) {
		$r=CkJavaKeyStore_FindPrivateKey($this->_cPtr,$password,$alias,$caseSensitive);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPrivateKey($r);
		}
		return $r;
	}

	function FindTrustedCert($alias,$caseSensitive) {
		$r=CkJavaKeyStore_FindTrustedCert($this->_cPtr,$alias,$caseSensitive);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetCertChain($index) {
		$r=CkJavaKeyStore_GetCertChain($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCertChain($r);
		}
		return $r;
	}

	function GetPrivateKey($password,$index) {
		$r=CkJavaKeyStore_GetPrivateKey($this->_cPtr,$password,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPrivateKey($r);
		}
		return $r;
	}

	function getPrivateKeyAlias($index) {
		return CkJavaKeyStore_getPrivateKeyAlias($this->_cPtr,$index);
	}

	function privateKeyAlias($index) {
		return CkJavaKeyStore_privateKeyAlias($this->_cPtr,$index);
	}

	function getSecretKey($password,$index,$encoding) {
		return CkJavaKeyStore_getSecretKey($this->_cPtr,$password,$index,$encoding);
	}

	function secretKey($password,$index,$encoding) {
		return CkJavaKeyStore_secretKey($this->_cPtr,$password,$index,$encoding);
	}

	function getSecretKeyAlias($index) {
		return CkJavaKeyStore_getSecretKeyAlias($this->_cPtr,$index);
	}

	function secretKeyAlias($index) {
		return CkJavaKeyStore_secretKeyAlias($this->_cPtr,$index);
	}

	function GetTrustedCert($index) {
		$r=CkJavaKeyStore_GetTrustedCert($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function getTrustedCertAlias($index) {
		return CkJavaKeyStore_getTrustedCertAlias($this->_cPtr,$index);
	}

	function trustedCertAlias($index) {
		return CkJavaKeyStore_trustedCertAlias($this->_cPtr,$index);
	}

	function LoadBd($password,$bd) {
		return CkJavaKeyStore_LoadBd($this->_cPtr,$password,$bd);
	}

	function LoadBinary($password,$jksData) {
		return CkJavaKeyStore_LoadBinary($this->_cPtr,$password,$jksData);
	}

	function LoadEncoded($password,$jksEncData,$encoding) {
		return CkJavaKeyStore_LoadEncoded($this->_cPtr,$password,$jksEncData,$encoding);
	}

	function LoadFile($password,$path) {
		return CkJavaKeyStore_LoadFile($this->_cPtr,$password,$path);
	}

	function LoadJwkSet($password,$jwkSet) {
		return CkJavaKeyStore_LoadJwkSet($this->_cPtr,$password,$jwkSet);
	}

	function PrivateKeyAt($password,$index,$privKey) {
		return CkJavaKeyStore_PrivateKeyAt($this->_cPtr,$password,$index,$privKey);
	}

	function PrivateKeyOf($password,$alias,$caseSensitive,$privKey) {
		return CkJavaKeyStore_PrivateKeyOf($this->_cPtr,$password,$alias,$caseSensitive,$privKey);
	}

	function RemoveEntry($entryType,$index) {
		return CkJavaKeyStore_RemoveEntry($this->_cPtr,$entryType,$index);
	}

	function SetAlias($entryType,$index,$alias) {
		return CkJavaKeyStore_SetAlias($this->_cPtr,$entryType,$index,$alias);
	}

	function ToBd($password,$bd) {
		return CkJavaKeyStore_ToBd($this->_cPtr,$password,$bd);
	}

	function ToBinary($password,$outBytes) {
		return CkJavaKeyStore_ToBinary($this->_cPtr,$password,$outBytes);
	}

	function toEncodedString($password,$encoding) {
		return CkJavaKeyStore_toEncodedString($this->_cPtr,$password,$encoding);
	}

	function ToFile($password,$path) {
		return CkJavaKeyStore_ToFile($this->_cPtr,$password,$path);
	}

	function ToJwkSet($password,$sbJwkSet) {
		return CkJavaKeyStore_ToJwkSet($this->_cPtr,$password,$sbJwkSet);
	}

	function ToPem($password) {
		$r=CkJavaKeyStore_ToPem($this->_cPtr,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPem($r);
		}
		return $r;
	}

	function ToPemObj($password,$pemObj) {
		return CkJavaKeyStore_ToPemObj($this->_cPtr,$password,$pemObj);
	}

	function ToPfx($password) {
		$r=CkJavaKeyStore_ToPfx($this->_cPtr,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPfx($r);
		}
		return $r;
	}

	function ToPfxObj($password,$pfxObj) {
		return CkJavaKeyStore_ToPfxObj($this->_cPtr,$password,$pfxObj);
	}

	function TrustedCertAt($index,$cert) {
		return CkJavaKeyStore_TrustedCertAt($this->_cPtr,$index,$cert);
	}

	function TrustedCertOf($alias,$caseSensitive,$cert) {
		return CkJavaKeyStore_TrustedCertOf($this->_cPtr,$alias,$caseSensitive,$cert);
	}

	function UseCertVault($vault) {
		return CkJavaKeyStore_UseCertVault($this->_cPtr,$vault);
	}
}

class CkJsonArray {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkJsonArray') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkJsonArray();
	}

	function get_Utf8() {
		return CkJsonArray_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkJsonArray_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkJsonArray_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkJsonArray_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkJsonArray_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EmitCompact() {
		return CkJsonArray_get_EmitCompact($this->_cPtr);
	}

	function put_EmitCompact($newVal) {
		CkJsonArray_put_EmitCompact($this->_cPtr,$newVal);
	}

	function get_EmitCrlf() {
		return CkJsonArray_get_EmitCrlf($this->_cPtr);
	}

	function put_EmitCrlf($newVal) {
		CkJsonArray_put_EmitCrlf($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkJsonArray_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkJsonArray_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkJsonArray_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkJsonArray_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkJsonArray_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkJsonArray_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkJsonArray_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkJsonArray_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Size() {
		return CkJsonArray_get_Size($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkJsonArray_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkJsonArray_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkJsonArray_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkJsonArray_version($this->_cPtr);
	}

	function AddArrayAt($index) {
		return CkJsonArray_AddArrayAt($this->_cPtr,$index);
	}

	function AddArrayAt2($index,$jarr) {
		return CkJsonArray_AddArrayAt2($this->_cPtr,$index,$jarr);
	}

	function AddBoolAt($index,$value) {
		return CkJsonArray_AddBoolAt($this->_cPtr,$index,$value);
	}

	function AddIntAt($index,$value) {
		return CkJsonArray_AddIntAt($this->_cPtr,$index,$value);
	}

	function AddNullAt($index) {
		return CkJsonArray_AddNullAt($this->_cPtr,$index);
	}

	function AddNumberAt($index,$numericStr) {
		return CkJsonArray_AddNumberAt($this->_cPtr,$index,$numericStr);
	}

	function AddObjectAt($index) {
		return CkJsonArray_AddObjectAt($this->_cPtr,$index);
	}

	function AddObjectAt2($index,$json) {
		return CkJsonArray_AddObjectAt2($this->_cPtr,$index,$json);
	}

	function AddObjectCopyAt($index,$jsonObj) {
		return CkJsonArray_AddObjectCopyAt($this->_cPtr,$index,$jsonObj);
	}

	function AddStringAt($index,$value) {
		return CkJsonArray_AddStringAt($this->_cPtr,$index,$value);
	}

	function AddUIntAt($index,$value) {
		return CkJsonArray_AddUIntAt($this->_cPtr,$index,$value);
	}

	function AppendArrayItems($jarr) {
		return CkJsonArray_AppendArrayItems($this->_cPtr,$jarr);
	}

	function ArrayAt($index) {
		$r=CkJsonArray_ArrayAt($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonArray($r);
		}
		return $r;
	}

	function ArrayAt2($index,$jarr) {
		return CkJsonArray_ArrayAt2($this->_cPtr,$index,$jarr);
	}

	function BoolAt($index) {
		return CkJsonArray_BoolAt($this->_cPtr,$index);
	}

	function Clear() {
		CkJsonArray_Clear($this->_cPtr);
	}

	function DateAt($index,$dateTime) {
		return CkJsonArray_DateAt($this->_cPtr,$index,$dateTime);
	}

	function DeleteAt($index) {
		return CkJsonArray_DeleteAt($this->_cPtr,$index);
	}

	function DtAt($index,$bLocal,$dt) {
		return CkJsonArray_DtAt($this->_cPtr,$index,$bLocal,$dt);
	}

	function emit() {
		return CkJsonArray_emit($this->_cPtr);
	}

	function EmitSb($sb) {
		return CkJsonArray_EmitSb($this->_cPtr,$sb);
	}

	function FindObject($name,$value,$caseSensitive) {
		return CkJsonArray_FindObject($this->_cPtr,$name,$value,$caseSensitive);
	}

	function FindString($value,$caseSensitive) {
		return CkJsonArray_FindString($this->_cPtr,$value,$caseSensitive);
	}

	function IntAt($index) {
		return CkJsonArray_IntAt($this->_cPtr,$index);
	}

	function IsNullAt($index) {
		return CkJsonArray_IsNullAt($this->_cPtr,$index);
	}

	function Load($jsonArray) {
		return CkJsonArray_Load($this->_cPtr,$jsonArray);
	}

	function LoadSb($sb) {
		return CkJsonArray_LoadSb($this->_cPtr,$sb);
	}

	function ObjectAt($index) {
		$r=CkJsonArray_ObjectAt($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function ObjectAt2($index,$jsonObj) {
		return CkJsonArray_ObjectAt2($this->_cPtr,$index,$jsonObj);
	}

	function SetBoolAt($index,$value) {
		return CkJsonArray_SetBoolAt($this->_cPtr,$index,$value);
	}

	function SetIntAt($index,$value) {
		return CkJsonArray_SetIntAt($this->_cPtr,$index,$value);
	}

	function SetNullAt($index) {
		return CkJsonArray_SetNullAt($this->_cPtr,$index);
	}

	function SetNumberAt($index,$value) {
		return CkJsonArray_SetNumberAt($this->_cPtr,$index,$value);
	}

	function SetStringAt($index,$value) {
		return CkJsonArray_SetStringAt($this->_cPtr,$index,$value);
	}

	function SetUIntAt($index,$value) {
		return CkJsonArray_SetUIntAt($this->_cPtr,$index,$value);
	}

	function stringAt($index) {
		return CkJsonArray_stringAt($this->_cPtr,$index);
	}

	function Swap($index1,$index2) {
		return CkJsonArray_Swap($this->_cPtr,$index1,$index2);
	}

	function TypeAt($index) {
		return CkJsonArray_TypeAt($this->_cPtr,$index);
	}

	function UIntAt($index) {
		return CkJsonArray_UIntAt($this->_cPtr,$index);
	}
}

class CkJsonObject {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkJsonObject') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkJsonObject();
	}

	function get_Utf8() {
		return CkJsonObject_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkJsonObject_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkJsonObject_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkJsonObject_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkJsonObject_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DelimiterChar($str) {
		CkJsonObject_get_DelimiterChar($this->_cPtr,$str);
	}

	function delimiterChar() {
		return CkJsonObject_delimiterChar($this->_cPtr);
	}

	function put_DelimiterChar($newVal) {
		CkJsonObject_put_DelimiterChar($this->_cPtr,$newVal);
	}

	function get_EmitCompact() {
		return CkJsonObject_get_EmitCompact($this->_cPtr);
	}

	function put_EmitCompact($newVal) {
		CkJsonObject_put_EmitCompact($this->_cPtr,$newVal);
	}

	function get_EmitCrLf() {
		return CkJsonObject_get_EmitCrLf($this->_cPtr);
	}

	function put_EmitCrLf($newVal) {
		CkJsonObject_put_EmitCrLf($this->_cPtr,$newVal);
	}

	function get_I() {
		return CkJsonObject_get_I($this->_cPtr);
	}

	function put_I($newVal) {
		CkJsonObject_put_I($this->_cPtr,$newVal);
	}

	function get_J() {
		return CkJsonObject_get_J($this->_cPtr);
	}

	function put_J($newVal) {
		CkJsonObject_put_J($this->_cPtr,$newVal);
	}

	function get_K() {
		return CkJsonObject_get_K($this->_cPtr);
	}

	function put_K($newVal) {
		CkJsonObject_put_K($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkJsonObject_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkJsonObject_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkJsonObject_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkJsonObject_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkJsonObject_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkJsonObject_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkJsonObject_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkJsonObject_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LowerCaseNames() {
		return CkJsonObject_get_LowerCaseNames($this->_cPtr);
	}

	function put_LowerCaseNames($newVal) {
		CkJsonObject_put_LowerCaseNames($this->_cPtr,$newVal);
	}

	function get_PathPrefix($str) {
		CkJsonObject_get_PathPrefix($this->_cPtr,$str);
	}

	function pathPrefix() {
		return CkJsonObject_pathPrefix($this->_cPtr);
	}

	function put_PathPrefix($newVal) {
		CkJsonObject_put_PathPrefix($this->_cPtr,$newVal);
	}

	function get_Size() {
		return CkJsonObject_get_Size($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkJsonObject_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkJsonObject_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkJsonObject_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkJsonObject_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkJsonObject_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkJsonObject_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkJsonObject_version($this->_cPtr);
	}

	function AddArrayAt($index,$name) {
		return CkJsonObject_AddArrayAt($this->_cPtr,$index,$name);
	}

	function AddArrayCopyAt($index,$name,$jarr) {
		return CkJsonObject_AddArrayCopyAt($this->_cPtr,$index,$name,$jarr);
	}

	function AddBoolAt($index,$name,$value) {
		return CkJsonObject_AddBoolAt($this->_cPtr,$index,$name,$value);
	}

	function AddIntAt($index,$name,$value) {
		return CkJsonObject_AddIntAt($this->_cPtr,$index,$name,$value);
	}

	function AddNullAt($index,$name) {
		return CkJsonObject_AddNullAt($this->_cPtr,$index,$name);
	}

	function AddNumberAt($index,$name,$numericStr) {
		return CkJsonObject_AddNumberAt($this->_cPtr,$index,$name,$numericStr);
	}

	function AddObjectAt($index,$name) {
		return CkJsonObject_AddObjectAt($this->_cPtr,$index,$name);
	}

	function AddObjectCopyAt($index,$name,$jsonObj) {
		return CkJsonObject_AddObjectCopyAt($this->_cPtr,$index,$name,$jsonObj);
	}

	function AddStringAt($index,$name,$value) {
		return CkJsonObject_AddStringAt($this->_cPtr,$index,$name,$value);
	}

	function AppendArray($name) {
		$r=CkJsonObject_AppendArray($this->_cPtr,$name);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonArray($r);
		}
		return $r;
	}

	function AppendArray2($name,$jarr) {
		return CkJsonObject_AppendArray2($this->_cPtr,$name,$jarr);
	}

	function AppendArrayCopy($name,$jarr) {
		return CkJsonObject_AppendArrayCopy($this->_cPtr,$name,$jarr);
	}

	function AppendBool($name,$value) {
		return CkJsonObject_AppendBool($this->_cPtr,$name,$value);
	}

	function AppendInt($name,$value) {
		return CkJsonObject_AppendInt($this->_cPtr,$name,$value);
	}

	function AppendObject($name) {
		$r=CkJsonObject_AppendObject($this->_cPtr,$name);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function AppendObject2($name,$jsonObj) {
		return CkJsonObject_AppendObject2($this->_cPtr,$name,$jsonObj);
	}

	function AppendObjectCopy($name,$jsonObj) {
		return CkJsonObject_AppendObjectCopy($this->_cPtr,$name,$jsonObj);
	}

	function AppendString($name,$value) {
		return CkJsonObject_AppendString($this->_cPtr,$name,$value);
	}

	function AppendStringArray($name,$values) {
		return CkJsonObject_AppendStringArray($this->_cPtr,$name,$values);
	}

	function ArrayAt($index) {
		$r=CkJsonObject_ArrayAt($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonArray($r);
		}
		return $r;
	}

	function ArrayAt2($index,$jarr) {
		return CkJsonObject_ArrayAt2($this->_cPtr,$index,$jarr);
	}

	function ArrayOf($jsonPath) {
		$r=CkJsonObject_ArrayOf($this->_cPtr,$jsonPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonArray($r);
		}
		return $r;
	}

	function ArrayOf2($jsonPath,$jarr) {
		return CkJsonObject_ArrayOf2($this->_cPtr,$jsonPath,$jarr);
	}

	function BoolAt($index) {
		return CkJsonObject_BoolAt($this->_cPtr,$index);
	}

	function BoolOf($jsonPath) {
		return CkJsonObject_BoolOf($this->_cPtr,$jsonPath);
	}

	function BytesOf($jsonPath,$encoding,$bd) {
		return CkJsonObject_BytesOf($this->_cPtr,$jsonPath,$encoding,$bd);
	}

	function Clear() {
		CkJsonObject_Clear($this->_cPtr);
	}

	function c_Clone() {
		$r=CkJsonObject_c_Clone($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function CopyRef($jsonObj) {
		return CkJsonObject_CopyRef($this->_cPtr,$jsonObj);
	}

	function DateOf($jsonPath,$dateTime) {
		return CkJsonObject_DateOf($this->_cPtr,$jsonPath,$dateTime);
	}

	function Delete($name) {
		return CkJsonObject_Delete($this->_cPtr,$name);
	}

	function DeleteAt($index) {
		return CkJsonObject_DeleteAt($this->_cPtr,$index);
	}

	function DeleteRecords($arrayPath,$relpath,$value,$caseSensitive) {
		return CkJsonObject_DeleteRecords($this->_cPtr,$arrayPath,$relpath,$value,$caseSensitive);
	}

	function DtOf($jsonPath,$bLocal,$dt) {
		return CkJsonObject_DtOf($this->_cPtr,$jsonPath,$bLocal,$dt);
	}

	function emit() {
		return CkJsonObject_emit($this->_cPtr);
	}

	function EmitBd($bd) {
		return CkJsonObject_EmitBd($this->_cPtr,$bd);
	}

	function EmitSb($sb) {
		return CkJsonObject_EmitSb($this->_cPtr,$sb);
	}

	function emitWithSubs($subs,$omitEmpty) {
		return CkJsonObject_emitWithSubs($this->_cPtr,$subs,$omitEmpty);
	}

	function FindObjectWithMember($name) {
		$r=CkJsonObject_FindObjectWithMember($this->_cPtr,$name);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function FindObjectWithMember2($name,$jsonObj) {
		return CkJsonObject_FindObjectWithMember2($this->_cPtr,$name,$jsonObj);
	}

	function FindRecord($arrayPath,$relPath,$value,$caseSensitive) {
		$r=CkJsonObject_FindRecord($this->_cPtr,$arrayPath,$relPath,$value,$caseSensitive);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function FindRecord2($arrayPath,$relPath,$value,$caseSensitive,$jsonObj) {
		return CkJsonObject_FindRecord2($this->_cPtr,$arrayPath,$relPath,$value,$caseSensitive,$jsonObj);
	}

	function findRecordString($arrayPath,$relPath,$value,$caseSensitive,$retRelPath) {
		return CkJsonObject_findRecordString($this->_cPtr,$arrayPath,$relPath,$value,$caseSensitive,$retRelPath);
	}

	function FirebaseApplyEvent($name,$data) {
		return CkJsonObject_FirebaseApplyEvent($this->_cPtr,$name,$data);
	}

	function FirebasePatch($jsonPath,$jsonData) {
		return CkJsonObject_FirebasePatch($this->_cPtr,$jsonPath,$jsonData);
	}

	function FirebasePut($jsonPath,$value) {
		return CkJsonObject_FirebasePut($this->_cPtr,$jsonPath,$value);
	}

	function GetDocRoot() {
		$r=CkJsonObject_GetDocRoot($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function GetDocRoot2($docRoot) {
		return CkJsonObject_GetDocRoot2($this->_cPtr,$docRoot);
	}

	function HasMember($jsonPath) {
		return CkJsonObject_HasMember($this->_cPtr,$jsonPath);
	}

	function IndexOf($name) {
		return CkJsonObject_IndexOf($this->_cPtr,$name);
	}

	function IntAt($index) {
		return CkJsonObject_IntAt($this->_cPtr,$index);
	}

	function IntOf($jsonPath) {
		return CkJsonObject_IntOf($this->_cPtr,$jsonPath);
	}

	function IsNullAt($index) {
		return CkJsonObject_IsNullAt($this->_cPtr,$index);
	}

	function IsNullOf($jsonPath) {
		return CkJsonObject_IsNullOf($this->_cPtr,$jsonPath);
	}

	function JsonTypeOf($jsonPath) {
		return CkJsonObject_JsonTypeOf($this->_cPtr,$jsonPath);
	}

	function Load($json) {
		return CkJsonObject_Load($this->_cPtr,$json);
	}

	function LoadBd($bd) {
		return CkJsonObject_LoadBd($this->_cPtr,$bd);
	}

	function LoadFile($path) {
		return CkJsonObject_LoadFile($this->_cPtr,$path);
	}

	function LoadPredefined($name) {
		return CkJsonObject_LoadPredefined($this->_cPtr,$name);
	}

	function LoadSb($sb) {
		return CkJsonObject_LoadSb($this->_cPtr,$sb);
	}

	function MakeCopy($json) {
		return CkJsonObject_MakeCopy($this->_cPtr,$json);
	}

	function MoveMember($fromIndex,$toIndex) {
		return CkJsonObject_MoveMember($this->_cPtr,$fromIndex,$toIndex);
	}

	function nameAt($index) {
		return CkJsonObject_nameAt($this->_cPtr,$index);
	}

	function ObjectAt($index) {
		$r=CkJsonObject_ObjectAt($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function ObjectAt2($index,$jsonObj) {
		return CkJsonObject_ObjectAt2($this->_cPtr,$index,$jsonObj);
	}

	function ObjectOf($jsonPath) {
		$r=CkJsonObject_ObjectOf($this->_cPtr,$jsonPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function ObjectOf2($jsonPath,$jsonObj) {
		return CkJsonObject_ObjectOf2($this->_cPtr,$jsonPath,$jsonObj);
	}

	function Predefine($name) {
		return CkJsonObject_Predefine($this->_cPtr,$name);
	}

	function Rename($oldName,$newName) {
		return CkJsonObject_Rename($this->_cPtr,$oldName,$newName);
	}

	function RenameAt($index,$name) {
		return CkJsonObject_RenameAt($this->_cPtr,$index,$name);
	}

	function SetBoolAt($index,$value) {
		return CkJsonObject_SetBoolAt($this->_cPtr,$index,$value);
	}

	function SetBoolOf($jsonPath,$value) {
		return CkJsonObject_SetBoolOf($this->_cPtr,$jsonPath,$value);
	}

	function SetIntAt($index,$value) {
		return CkJsonObject_SetIntAt($this->_cPtr,$index,$value);
	}

	function SetIntOf($jsonPath,$value) {
		return CkJsonObject_SetIntOf($this->_cPtr,$jsonPath,$value);
	}

	function SetNullAt($index) {
		return CkJsonObject_SetNullAt($this->_cPtr,$index);
	}

	function SetNullOf($jsonPath) {
		return CkJsonObject_SetNullOf($this->_cPtr,$jsonPath);
	}

	function SetNumberAt($index,$value) {
		return CkJsonObject_SetNumberAt($this->_cPtr,$index,$value);
	}

	function SetNumberOf($jsonPath,$value) {
		return CkJsonObject_SetNumberOf($this->_cPtr,$jsonPath,$value);
	}

	function SetStringAt($index,$value) {
		return CkJsonObject_SetStringAt($this->_cPtr,$index,$value);
	}

	function SetStringOf($jsonPath,$value) {
		return CkJsonObject_SetStringOf($this->_cPtr,$jsonPath,$value);
	}

	function SizeOfArray($jsonPath) {
		return CkJsonObject_SizeOfArray($this->_cPtr,$jsonPath);
	}

	function Sort($ascending,$caseSensitive) {
		CkJsonObject_Sort($this->_cPtr,$ascending,$caseSensitive);
	}

	function stringAt($index) {
		return CkJsonObject_stringAt($this->_cPtr,$index);
	}

	function stringOf($jsonPath) {
		return CkJsonObject_stringOf($this->_cPtr,$jsonPath);
	}

	function StringOfEquals($jsonPath,$value,$caseSensitive) {
		return CkJsonObject_StringOfEquals($this->_cPtr,$jsonPath,$value,$caseSensitive);
	}

	function StringOfSb($jsonPath,$sb) {
		return CkJsonObject_StringOfSb($this->_cPtr,$jsonPath,$sb);
	}

	function Swap($index1,$index2) {
		return CkJsonObject_Swap($this->_cPtr,$index1,$index2);
	}

	function TypeAt($index) {
		return CkJsonObject_TypeAt($this->_cPtr,$index);
	}

	function UIntOf($jsonPath) {
		return CkJsonObject_UIntOf($this->_cPtr,$jsonPath);
	}

	function UpdateBd($jsonPath,$encoding,$bd) {
		return CkJsonObject_UpdateBd($this->_cPtr,$jsonPath,$encoding,$bd);
	}

	function UpdateBool($jsonPath,$value) {
		return CkJsonObject_UpdateBool($this->_cPtr,$jsonPath,$value);
	}

	function UpdateInt($jsonPath,$value) {
		return CkJsonObject_UpdateInt($this->_cPtr,$jsonPath,$value);
	}

	function UpdateNewArray($jsonPath) {
		return CkJsonObject_UpdateNewArray($this->_cPtr,$jsonPath);
	}

	function UpdateNewObject($jsonPath) {
		return CkJsonObject_UpdateNewObject($this->_cPtr,$jsonPath);
	}

	function UpdateNull($jsonPath) {
		return CkJsonObject_UpdateNull($this->_cPtr,$jsonPath);
	}

	function UpdateNumber($jsonPath,$numericStr) {
		return CkJsonObject_UpdateNumber($this->_cPtr,$jsonPath,$numericStr);
	}

	function UpdateSb($jsonPath,$sb) {
		return CkJsonObject_UpdateSb($this->_cPtr,$jsonPath,$sb);
	}

	function UpdateString($jsonPath,$value) {
		return CkJsonObject_UpdateString($this->_cPtr,$jsonPath,$value);
	}

	function UpdateUInt($jsonPath,$value) {
		return CkJsonObject_UpdateUInt($this->_cPtr,$jsonPath,$value);
	}

	function WriteFile($path) {
		return CkJsonObject_WriteFile($this->_cPtr,$path);
	}
}

class CkJwe {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkJwe') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkJwe();
	}

	function get_Utf8() {
		return CkJwe_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkJwe_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkJwe_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkJwe_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkJwe_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkJwe_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkJwe_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkJwe_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkJwe_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkJwe_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkJwe_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkJwe_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkJwe_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumRecipients() {
		return CkJwe_get_NumRecipients($this->_cPtr);
	}

	function get_PreferCompact() {
		return CkJwe_get_PreferCompact($this->_cPtr);
	}

	function put_PreferCompact($newVal) {
		CkJwe_put_PreferCompact($this->_cPtr,$newVal);
	}

	function get_PreferFlattened() {
		return CkJwe_get_PreferFlattened($this->_cPtr);
	}

	function put_PreferFlattened($newVal) {
		CkJwe_put_PreferFlattened($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkJwe_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkJwe_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkJwe_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkJwe_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkJwe_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkJwe_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkJwe_version($this->_cPtr);
	}

	function decrypt($index,$charset) {
		return CkJwe_decrypt($this->_cPtr,$index,$charset);
	}

	function DecryptBd($index,$bd) {
		return CkJwe_DecryptBd($this->_cPtr,$index,$bd);
	}

	function DecryptSb($index,$charset,$contentSb) {
		return CkJwe_DecryptSb($this->_cPtr,$index,$charset,$contentSb);
	}

	function encrypt($content,$charset) {
		return CkJwe_encrypt($this->_cPtr,$content,$charset);
	}

	function EncryptBd($contentBd,$jweSb) {
		return CkJwe_EncryptBd($this->_cPtr,$contentBd,$jweSb);
	}

	function EncryptSb($contentSb,$charset,$jweSb) {
		return CkJwe_EncryptSb($this->_cPtr,$contentSb,$charset,$jweSb);
	}

	function FindRecipient($paramName,$paramValue,$caseSensitive) {
		return CkJwe_FindRecipient($this->_cPtr,$paramName,$paramValue,$caseSensitive);
	}

	function GetHeader($json) {
		return CkJwe_GetHeader($this->_cPtr,$json);
	}

	function GetProtectedHeader($json) {
		return CkJwe_GetProtectedHeader($this->_cPtr,$json);
	}

	function LoadJwe($jwe) {
		return CkJwe_LoadJwe($this->_cPtr,$jwe);
	}

	function LoadJweSb($sb) {
		return CkJwe_LoadJweSb($this->_cPtr,$sb);
	}

	function SetAad($aad,$charset) {
		return CkJwe_SetAad($this->_cPtr,$aad,$charset);
	}

	function SetAadBd($aad) {
		return CkJwe_SetAadBd($this->_cPtr,$aad);
	}

	function SetPassword($index,$password) {
		return CkJwe_SetPassword($this->_cPtr,$index,$password);
	}

	function SetPrivateKey($index,$privKey) {
		return CkJwe_SetPrivateKey($this->_cPtr,$index,$privKey);
	}

	function SetProtectedHeader($json) {
		return CkJwe_SetProtectedHeader($this->_cPtr,$json);
	}

	function SetPublicKey($index,$pubKey) {
		return CkJwe_SetPublicKey($this->_cPtr,$index,$pubKey);
	}

	function SetRecipientHeader($index,$json) {
		return CkJwe_SetRecipientHeader($this->_cPtr,$index,$json);
	}

	function SetUnprotectedHeader($json) {
		return CkJwe_SetUnprotectedHeader($this->_cPtr,$json);
	}

	function SetWrappingKey($index,$encodedKey,$encoding) {
		return CkJwe_SetWrappingKey($this->_cPtr,$index,$encodedKey,$encoding);
	}
}

class CkJws {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkJws') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkJws();
	}

	function get_Utf8() {
		return CkJws_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkJws_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkJws_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkJws_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkJws_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkJws_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkJws_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkJws_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkJws_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkJws_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkJws_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkJws_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkJws_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumSignatures() {
		return CkJws_get_NumSignatures($this->_cPtr);
	}

	function get_PreferCompact() {
		return CkJws_get_PreferCompact($this->_cPtr);
	}

	function put_PreferCompact($newVal) {
		CkJws_put_PreferCompact($this->_cPtr,$newVal);
	}

	function get_PreferFlattened() {
		return CkJws_get_PreferFlattened($this->_cPtr);
	}

	function put_PreferFlattened($newVal) {
		CkJws_put_PreferFlattened($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkJws_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkJws_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkJws_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkJws_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkJws_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkJws_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkJws_version($this->_cPtr);
	}

	function createJws() {
		return CkJws_createJws($this->_cPtr);
	}

	function CreateJwsSb($sbJws) {
		return CkJws_CreateJwsSb($this->_cPtr,$sbJws);
	}

	function getPayload($charset) {
		return CkJws_getPayload($this->_cPtr,$charset);
	}

	function payload($charset) {
		return CkJws_payload($this->_cPtr,$charset);
	}

	function GetPayloadBd($binData) {
		return CkJws_GetPayloadBd($this->_cPtr,$binData);
	}

	function GetPayloadSb($charset,$sbPayload) {
		return CkJws_GetPayloadSb($this->_cPtr,$charset,$sbPayload);
	}

	function GetProtectedH($index,$json) {
		return CkJws_GetProtectedH($this->_cPtr,$index,$json);
	}

	function GetProtectedHeader($index) {
		$r=CkJws_GetProtectedHeader($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function GetUnprotectedH($index,$json) {
		return CkJws_GetUnprotectedH($this->_cPtr,$index,$json);
	}

	function GetUnprotectedHeader($index) {
		$r=CkJws_GetUnprotectedHeader($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LoadJws($jwsStr) {
		return CkJws_LoadJws($this->_cPtr,$jwsStr);
	}

	function LoadJwsSb($sbJws) {
		return CkJws_LoadJwsSb($this->_cPtr,$sbJws);
	}

	function SetMacKey($index,$key,$encoding) {
		return CkJws_SetMacKey($this->_cPtr,$index,$key,$encoding);
	}

	function SetMacKeyBd($index,$key) {
		return CkJws_SetMacKeyBd($this->_cPtr,$index,$key);
	}

	function SetPayload($payload,$charset,$includeBom) {
		return CkJws_SetPayload($this->_cPtr,$payload,$charset,$includeBom);
	}

	function SetPayloadBd($binData) {
		return CkJws_SetPayloadBd($this->_cPtr,$binData);
	}

	function SetPayloadSb($sbPayload,$charset,$includeBom) {
		return CkJws_SetPayloadSb($this->_cPtr,$sbPayload,$charset,$includeBom);
	}

	function SetPrivateKey($index,$privKey) {
		return CkJws_SetPrivateKey($this->_cPtr,$index,$privKey);
	}

	function SetProtectedHeader($index,$json) {
		return CkJws_SetProtectedHeader($this->_cPtr,$index,$json);
	}

	function SetPublicKey($index,$pubKey) {
		return CkJws_SetPublicKey($this->_cPtr,$index,$pubKey);
	}

	function SetUnprotectedHeader($index,$json) {
		return CkJws_SetUnprotectedHeader($this->_cPtr,$index,$json);
	}

	function Validate($index) {
		return CkJws_Validate($this->_cPtr,$index);
	}
}

class CkJwt {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkJwt') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkJwt();
	}

	function get_Utf8() {
		return CkJwt_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkJwt_put_Utf8($this->_cPtr,$b);
	}

	function get_AutoCompact() {
		return CkJwt_get_AutoCompact($this->_cPtr);
	}

	function put_AutoCompact($newVal) {
		CkJwt_put_AutoCompact($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkJwt_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkJwt_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkJwt_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkJwt_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkJwt_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkJwt_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkJwt_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkJwt_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkJwt_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkJwt_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkJwt_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkJwt_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkJwt_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkJwt_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkJwt_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkJwt_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkJwt_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkJwt_version($this->_cPtr);
	}

	function createJwt($header,$payload,$password) {
		return CkJwt_createJwt($this->_cPtr,$header,$payload,$password);
	}

	function createJwtCert($header,$payload,$cert) {
		return CkJwt_createJwtCert($this->_cPtr,$header,$payload,$cert);
	}

	function createJwtPk($header,$payload,$key) {
		return CkJwt_createJwtPk($this->_cPtr,$header,$payload,$key);
	}

	function GenNumericDate($numSecOffset) {
		return CkJwt_GenNumericDate($this->_cPtr,$numSecOffset);
	}

	function getHeader($token) {
		return CkJwt_getHeader($this->_cPtr,$token);
	}

	function header($token) {
		return CkJwt_header($this->_cPtr,$token);
	}

	function getPayload($token) {
		return CkJwt_getPayload($this->_cPtr,$token);
	}

	function payload($token) {
		return CkJwt_payload($this->_cPtr,$token);
	}

	function IsTimeValid($jwt,$leeway) {
		return CkJwt_IsTimeValid($this->_cPtr,$jwt,$leeway);
	}

	function VerifyJwt($token,$password) {
		return CkJwt_VerifyJwt($this->_cPtr,$token,$password);
	}

	function VerifyJwtPk($token,$key) {
		return CkJwt_VerifyJwtPk($this->_cPtr,$token,$key);
	}
}

class CkLog {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkLog') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkLog();
	}

	function get_Utf8() {
		return CkLog_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkLog_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkLog_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkLog_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkLog_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkLog_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkLog_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkLog_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkLog_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkLog_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkLog_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkLog_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkLog_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkLog_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkLog_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkLog_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkLog_version($this->_cPtr);
	}

	function Clear($initialTag) {
		CkLog_Clear($this->_cPtr,$initialTag);
	}

	function EnterContext($tag) {
		CkLog_EnterContext($this->_cPtr,$tag);
	}

	function LeaveContext() {
		CkLog_LeaveContext($this->_cPtr);
	}

	function LogData($tag,$message) {
		CkLog_LogData($this->_cPtr,$tag,$message);
	}

	function LogDataBase64($tag,$data) {
		CkLog_LogDataBase64($this->_cPtr,$tag,$data);
	}

	function LogDataHex($tag,$data) {
		CkLog_LogDataHex($this->_cPtr,$tag,$data);
	}

	function LogDataMax($tag,$message,$maxNumChars) {
		CkLog_LogDataMax($this->_cPtr,$tag,$message,$maxNumChars);
	}

	function LogDateTime($tag,$gmt) {
		CkLog_LogDateTime($this->_cPtr,$tag,$gmt);
	}

	function LogError($message) {
		CkLog_LogError($this->_cPtr,$message);
	}

	function LogInfo($message) {
		CkLog_LogInfo($this->_cPtr,$message);
	}

	function LogInt($tag,$value) {
		CkLog_LogInt($this->_cPtr,$tag,$value);
	}

	function LogTimestamp($tag) {
		CkLog_LogTimestamp($this->_cPtr,$tag);
	}
}

class CkMailMan {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkMailMan') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkMailMan();
	}

	function get_Utf8() {
		return CkMailMan_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkMailMan_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkMailMan_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkMailMan_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkMailMan_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_AllOrNone() {
		return CkMailMan_get_AllOrNone($this->_cPtr);
	}

	function put_AllOrNone($newVal) {
		CkMailMan_put_AllOrNone($this->_cPtr,$newVal);
	}

	function get_AutoFix() {
		return CkMailMan_get_AutoFix($this->_cPtr);
	}

	function put_AutoFix($newVal) {
		CkMailMan_put_AutoFix($this->_cPtr,$newVal);
	}

	function get_AutoGenMessageId() {
		return CkMailMan_get_AutoGenMessageId($this->_cPtr);
	}

	function put_AutoGenMessageId($newVal) {
		CkMailMan_put_AutoGenMessageId($this->_cPtr,$newVal);
	}

	function get_AutoSmtpRset() {
		return CkMailMan_get_AutoSmtpRset($this->_cPtr);
	}

	function put_AutoSmtpRset($newVal) {
		CkMailMan_put_AutoSmtpRset($this->_cPtr,$newVal);
	}

	function get_AutoUnwrapSecurity() {
		return CkMailMan_get_AutoUnwrapSecurity($this->_cPtr);
	}

	function put_AutoUnwrapSecurity($newVal) {
		CkMailMan_put_AutoUnwrapSecurity($this->_cPtr,$newVal);
	}

	function get_ClientIpAddress($str) {
		CkMailMan_get_ClientIpAddress($this->_cPtr,$str);
	}

	function clientIpAddress() {
		return CkMailMan_clientIpAddress($this->_cPtr);
	}

	function put_ClientIpAddress($newVal) {
		CkMailMan_put_ClientIpAddress($this->_cPtr,$newVal);
	}

	function get_ConnectFailReason() {
		return CkMailMan_get_ConnectFailReason($this->_cPtr);
	}

	function get_ConnectTimeout() {
		return CkMailMan_get_ConnectTimeout($this->_cPtr);
	}

	function put_ConnectTimeout($newVal) {
		CkMailMan_put_ConnectTimeout($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkMailMan_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkMailMan_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkMailMan_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DsnEnvid($str) {
		CkMailMan_get_DsnEnvid($this->_cPtr,$str);
	}

	function dsnEnvid() {
		return CkMailMan_dsnEnvid($this->_cPtr);
	}

	function put_DsnEnvid($newVal) {
		CkMailMan_put_DsnEnvid($this->_cPtr,$newVal);
	}

	function get_DsnNotify($str) {
		CkMailMan_get_DsnNotify($this->_cPtr,$str);
	}

	function dsnNotify() {
		return CkMailMan_dsnNotify($this->_cPtr);
	}

	function put_DsnNotify($newVal) {
		CkMailMan_put_DsnNotify($this->_cPtr,$newVal);
	}

	function get_DsnRet($str) {
		CkMailMan_get_DsnRet($this->_cPtr,$str);
	}

	function dsnRet() {
		return CkMailMan_dsnRet($this->_cPtr);
	}

	function put_DsnRet($newVal) {
		CkMailMan_put_DsnRet($this->_cPtr,$newVal);
	}

	function get_EmbedCertChain() {
		return CkMailMan_get_EmbedCertChain($this->_cPtr);
	}

	function put_EmbedCertChain($newVal) {
		CkMailMan_put_EmbedCertChain($this->_cPtr,$newVal);
	}

	function get_Filter($str) {
		CkMailMan_get_Filter($this->_cPtr,$str);
	}

	function filter() {
		return CkMailMan_filter($this->_cPtr);
	}

	function put_Filter($newVal) {
		CkMailMan_put_Filter($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkMailMan_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkMailMan_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_HeloHostname($str) {
		CkMailMan_get_HeloHostname($this->_cPtr,$str);
	}

	function heloHostname() {
		return CkMailMan_heloHostname($this->_cPtr);
	}

	function put_HeloHostname($newVal) {
		CkMailMan_put_HeloHostname($this->_cPtr,$newVal);
	}

	function get_HttpProxyAuthMethod($str) {
		CkMailMan_get_HttpProxyAuthMethod($this->_cPtr,$str);
	}

	function httpProxyAuthMethod() {
		return CkMailMan_httpProxyAuthMethod($this->_cPtr);
	}

	function put_HttpProxyAuthMethod($newVal) {
		CkMailMan_put_HttpProxyAuthMethod($this->_cPtr,$newVal);
	}

	function get_HttpProxyDomain($str) {
		CkMailMan_get_HttpProxyDomain($this->_cPtr,$str);
	}

	function httpProxyDomain() {
		return CkMailMan_httpProxyDomain($this->_cPtr);
	}

	function put_HttpProxyDomain($newVal) {
		CkMailMan_put_HttpProxyDomain($this->_cPtr,$newVal);
	}

	function get_HttpProxyHostname($str) {
		CkMailMan_get_HttpProxyHostname($this->_cPtr,$str);
	}

	function httpProxyHostname() {
		return CkMailMan_httpProxyHostname($this->_cPtr);
	}

	function put_HttpProxyHostname($newVal) {
		CkMailMan_put_HttpProxyHostname($this->_cPtr,$newVal);
	}

	function get_HttpProxyPassword($str) {
		CkMailMan_get_HttpProxyPassword($this->_cPtr,$str);
	}

	function httpProxyPassword() {
		return CkMailMan_httpProxyPassword($this->_cPtr);
	}

	function put_HttpProxyPassword($newVal) {
		CkMailMan_put_HttpProxyPassword($this->_cPtr,$newVal);
	}

	function get_HttpProxyPort() {
		return CkMailMan_get_HttpProxyPort($this->_cPtr);
	}

	function put_HttpProxyPort($newVal) {
		CkMailMan_put_HttpProxyPort($this->_cPtr,$newVal);
	}

	function get_HttpProxyUsername($str) {
		CkMailMan_get_HttpProxyUsername($this->_cPtr,$str);
	}

	function httpProxyUsername() {
		return CkMailMan_httpProxyUsername($this->_cPtr);
	}

	function put_HttpProxyUsername($newVal) {
		CkMailMan_put_HttpProxyUsername($this->_cPtr,$newVal);
	}

	function get_ImmediateDelete() {
		return CkMailMan_get_ImmediateDelete($this->_cPtr);
	}

	function put_ImmediateDelete($newVal) {
		CkMailMan_put_ImmediateDelete($this->_cPtr,$newVal);
	}

	function get_IncludeRootCert() {
		return CkMailMan_get_IncludeRootCert($this->_cPtr);
	}

	function put_IncludeRootCert($newVal) {
		CkMailMan_put_IncludeRootCert($this->_cPtr,$newVal);
	}

	function get_IsPop3Connected() {
		return CkMailMan_get_IsPop3Connected($this->_cPtr);
	}

	function get_IsSmtpConnected() {
		return CkMailMan_get_IsSmtpConnected($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkMailMan_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkMailMan_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkMailMan_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkMailMan_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkMailMan_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkMailMan_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkMailMan_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkMailMan_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LastSmtpStatus() {
		return CkMailMan_get_LastSmtpStatus($this->_cPtr);
	}

	function get_LastSmtpStatusMsg($str) {
		CkMailMan_get_LastSmtpStatusMsg($this->_cPtr,$str);
	}

	function lastSmtpStatusMsg() {
		return CkMailMan_lastSmtpStatusMsg($this->_cPtr);
	}

	function get_LogMailReceivedFilename($str) {
		CkMailMan_get_LogMailReceivedFilename($this->_cPtr,$str);
	}

	function logMailReceivedFilename() {
		return CkMailMan_logMailReceivedFilename($this->_cPtr);
	}

	function put_LogMailReceivedFilename($newVal) {
		CkMailMan_put_LogMailReceivedFilename($this->_cPtr,$newVal);
	}

	function get_LogMailSentFilename($str) {
		CkMailMan_get_LogMailSentFilename($this->_cPtr,$str);
	}

	function logMailSentFilename() {
		return CkMailMan_logMailSentFilename($this->_cPtr);
	}

	function put_LogMailSentFilename($newVal) {
		CkMailMan_put_LogMailSentFilename($this->_cPtr,$newVal);
	}

	function get_MailHost($str) {
		CkMailMan_get_MailHost($this->_cPtr,$str);
	}

	function mailHost() {
		return CkMailMan_mailHost($this->_cPtr);
	}

	function put_MailHost($newVal) {
		CkMailMan_put_MailHost($this->_cPtr,$newVal);
	}

	function get_MailPort() {
		return CkMailMan_get_MailPort($this->_cPtr);
	}

	function put_MailPort($newVal) {
		CkMailMan_put_MailPort($this->_cPtr,$newVal);
	}

	function get_MaxCount() {
		return CkMailMan_get_MaxCount($this->_cPtr);
	}

	function put_MaxCount($newVal) {
		CkMailMan_put_MaxCount($this->_cPtr,$newVal);
	}

	function get_OAuth2AccessToken($str) {
		CkMailMan_get_OAuth2AccessToken($this->_cPtr,$str);
	}

	function oAuth2AccessToken() {
		return CkMailMan_oAuth2AccessToken($this->_cPtr);
	}

	function put_OAuth2AccessToken($newVal) {
		CkMailMan_put_OAuth2AccessToken($this->_cPtr,$newVal);
	}

	function get_OpaqueSigning() {
		return CkMailMan_get_OpaqueSigning($this->_cPtr);
	}

	function put_OpaqueSigning($newVal) {
		CkMailMan_put_OpaqueSigning($this->_cPtr,$newVal);
	}

	function get_P7mEncryptAttachFilename($str) {
		CkMailMan_get_P7mEncryptAttachFilename($this->_cPtr,$str);
	}

	function p7mEncryptAttachFilename() {
		return CkMailMan_p7mEncryptAttachFilename($this->_cPtr);
	}

	function put_P7mEncryptAttachFilename($newVal) {
		CkMailMan_put_P7mEncryptAttachFilename($this->_cPtr,$newVal);
	}

	function get_P7mSigAttachFilename($str) {
		CkMailMan_get_P7mSigAttachFilename($this->_cPtr,$str);
	}

	function p7mSigAttachFilename() {
		return CkMailMan_p7mSigAttachFilename($this->_cPtr);
	}

	function put_P7mSigAttachFilename($newVal) {
		CkMailMan_put_P7mSigAttachFilename($this->_cPtr,$newVal);
	}

	function get_P7sSigAttachFilename($str) {
		CkMailMan_get_P7sSigAttachFilename($this->_cPtr,$str);
	}

	function p7sSigAttachFilename() {
		return CkMailMan_p7sSigAttachFilename($this->_cPtr);
	}

	function put_P7sSigAttachFilename($newVal) {
		CkMailMan_put_P7sSigAttachFilename($this->_cPtr,$newVal);
	}

	function get_PercentDoneScale() {
		return CkMailMan_get_PercentDoneScale($this->_cPtr);
	}

	function put_PercentDoneScale($newVal) {
		CkMailMan_put_PercentDoneScale($this->_cPtr,$newVal);
	}

	function get_Pop3SessionId() {
		return CkMailMan_get_Pop3SessionId($this->_cPtr);
	}

	function get_Pop3SessionLog($str) {
		CkMailMan_get_Pop3SessionLog($this->_cPtr,$str);
	}

	function pop3SessionLog() {
		return CkMailMan_pop3SessionLog($this->_cPtr);
	}

	function get_Pop3SPA() {
		return CkMailMan_get_Pop3SPA($this->_cPtr);
	}

	function put_Pop3SPA($newVal) {
		CkMailMan_put_Pop3SPA($this->_cPtr,$newVal);
	}

	function get_Pop3SslServerCertVerified() {
		return CkMailMan_get_Pop3SslServerCertVerified($this->_cPtr);
	}

	function get_Pop3Stls() {
		return CkMailMan_get_Pop3Stls($this->_cPtr);
	}

	function put_Pop3Stls($newVal) {
		CkMailMan_put_Pop3Stls($this->_cPtr,$newVal);
	}

	function get_Pop3StlsIfPossible() {
		return CkMailMan_get_Pop3StlsIfPossible($this->_cPtr);
	}

	function put_Pop3StlsIfPossible($newVal) {
		CkMailMan_put_Pop3StlsIfPossible($this->_cPtr,$newVal);
	}

	function get_PopPassword($str) {
		CkMailMan_get_PopPassword($this->_cPtr,$str);
	}

	function popPassword() {
		return CkMailMan_popPassword($this->_cPtr);
	}

	function put_PopPassword($newVal) {
		CkMailMan_put_PopPassword($this->_cPtr,$newVal);
	}

	function get_PopPasswordBase64($str) {
		CkMailMan_get_PopPasswordBase64($this->_cPtr,$str);
	}

	function popPasswordBase64() {
		return CkMailMan_popPasswordBase64($this->_cPtr);
	}

	function put_PopPasswordBase64($newVal) {
		CkMailMan_put_PopPasswordBase64($this->_cPtr,$newVal);
	}

	function get_PopSsl() {
		return CkMailMan_get_PopSsl($this->_cPtr);
	}

	function put_PopSsl($newVal) {
		CkMailMan_put_PopSsl($this->_cPtr,$newVal);
	}

	function get_PopUsername($str) {
		CkMailMan_get_PopUsername($this->_cPtr,$str);
	}

	function popUsername() {
		return CkMailMan_popUsername($this->_cPtr);
	}

	function put_PopUsername($newVal) {
		CkMailMan_put_PopUsername($this->_cPtr,$newVal);
	}

	function get_PreferIpv6() {
		return CkMailMan_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkMailMan_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_ReadTimeout() {
		return CkMailMan_get_ReadTimeout($this->_cPtr);
	}

	function put_ReadTimeout($newVal) {
		CkMailMan_put_ReadTimeout($this->_cPtr,$newVal);
	}

	function get_RequireSslCertVerify() {
		return CkMailMan_get_RequireSslCertVerify($this->_cPtr);
	}

	function put_RequireSslCertVerify($newVal) {
		CkMailMan_put_RequireSslCertVerify($this->_cPtr,$newVal);
	}

	function get_ResetDateOnLoad() {
		return CkMailMan_get_ResetDateOnLoad($this->_cPtr);
	}

	function put_ResetDateOnLoad($newVal) {
		CkMailMan_put_ResetDateOnLoad($this->_cPtr,$newVal);
	}

	function get_SendBufferSize() {
		return CkMailMan_get_SendBufferSize($this->_cPtr);
	}

	function put_SendBufferSize($newVal) {
		CkMailMan_put_SendBufferSize($this->_cPtr,$newVal);
	}

	function get_SendIndividual() {
		return CkMailMan_get_SendIndividual($this->_cPtr);
	}

	function put_SendIndividual($newVal) {
		CkMailMan_put_SendIndividual($this->_cPtr,$newVal);
	}

	function get_SizeLimit() {
		return CkMailMan_get_SizeLimit($this->_cPtr);
	}

	function put_SizeLimit($newVal) {
		CkMailMan_put_SizeLimit($this->_cPtr,$newVal);
	}

	function get_SmtpAuthMethod($str) {
		CkMailMan_get_SmtpAuthMethod($this->_cPtr,$str);
	}

	function smtpAuthMethod() {
		return CkMailMan_smtpAuthMethod($this->_cPtr);
	}

	function put_SmtpAuthMethod($newVal) {
		CkMailMan_put_SmtpAuthMethod($this->_cPtr,$newVal);
	}

	function get_SmtpFailReason($str) {
		CkMailMan_get_SmtpFailReason($this->_cPtr,$str);
	}

	function smtpFailReason() {
		return CkMailMan_smtpFailReason($this->_cPtr);
	}

	function get_SmtpHost($str) {
		CkMailMan_get_SmtpHost($this->_cPtr,$str);
	}

	function smtpHost() {
		return CkMailMan_smtpHost($this->_cPtr);
	}

	function put_SmtpHost($newVal) {
		CkMailMan_put_SmtpHost($this->_cPtr,$newVal);
	}

	function get_SmtpLoginDomain($str) {
		CkMailMan_get_SmtpLoginDomain($this->_cPtr,$str);
	}

	function smtpLoginDomain() {
		return CkMailMan_smtpLoginDomain($this->_cPtr);
	}

	function put_SmtpLoginDomain($newVal) {
		CkMailMan_put_SmtpLoginDomain($this->_cPtr,$newVal);
	}

	function get_SmtpMailFrom($str) {
		CkMailMan_get_SmtpMailFrom($this->_cPtr,$str);
	}

	function smtpMailFrom() {
		return CkMailMan_smtpMailFrom($this->_cPtr);
	}

	function put_SmtpMailFrom($newVal) {
		CkMailMan_put_SmtpMailFrom($this->_cPtr,$newVal);
	}

	function get_SmtpPassword($str) {
		CkMailMan_get_SmtpPassword($this->_cPtr,$str);
	}

	function smtpPassword() {
		return CkMailMan_smtpPassword($this->_cPtr);
	}

	function put_SmtpPassword($newVal) {
		CkMailMan_put_SmtpPassword($this->_cPtr,$newVal);
	}

	function get_SmtpPipelining() {
		return CkMailMan_get_SmtpPipelining($this->_cPtr);
	}

	function put_SmtpPipelining($newVal) {
		CkMailMan_put_SmtpPipelining($this->_cPtr,$newVal);
	}

	function get_SmtpPort() {
		return CkMailMan_get_SmtpPort($this->_cPtr);
	}

	function put_SmtpPort($newVal) {
		CkMailMan_put_SmtpPort($this->_cPtr,$newVal);
	}

	function get_SmtpSessionLog($str) {
		CkMailMan_get_SmtpSessionLog($this->_cPtr,$str);
	}

	function smtpSessionLog() {
		return CkMailMan_smtpSessionLog($this->_cPtr);
	}

	function get_SmtpSsl() {
		return CkMailMan_get_SmtpSsl($this->_cPtr);
	}

	function put_SmtpSsl($newVal) {
		CkMailMan_put_SmtpSsl($this->_cPtr,$newVal);
	}

	function get_SmtpSslServerCertVerified() {
		return CkMailMan_get_SmtpSslServerCertVerified($this->_cPtr);
	}

	function get_SmtpUsername($str) {
		CkMailMan_get_SmtpUsername($this->_cPtr,$str);
	}

	function smtpUsername() {
		return CkMailMan_smtpUsername($this->_cPtr);
	}

	function put_SmtpUsername($newVal) {
		CkMailMan_put_SmtpUsername($this->_cPtr,$newVal);
	}

	function get_SocksHostname($str) {
		CkMailMan_get_SocksHostname($this->_cPtr,$str);
	}

	function socksHostname() {
		return CkMailMan_socksHostname($this->_cPtr);
	}

	function put_SocksHostname($newVal) {
		CkMailMan_put_SocksHostname($this->_cPtr,$newVal);
	}

	function get_SocksPassword($str) {
		CkMailMan_get_SocksPassword($this->_cPtr,$str);
	}

	function socksPassword() {
		return CkMailMan_socksPassword($this->_cPtr);
	}

	function put_SocksPassword($newVal) {
		CkMailMan_put_SocksPassword($this->_cPtr,$newVal);
	}

	function get_SocksPort() {
		return CkMailMan_get_SocksPort($this->_cPtr);
	}

	function put_SocksPort($newVal) {
		CkMailMan_put_SocksPort($this->_cPtr,$newVal);
	}

	function get_SocksUsername($str) {
		CkMailMan_get_SocksUsername($this->_cPtr,$str);
	}

	function socksUsername() {
		return CkMailMan_socksUsername($this->_cPtr);
	}

	function put_SocksUsername($newVal) {
		CkMailMan_put_SocksUsername($this->_cPtr,$newVal);
	}

	function get_SocksVersion() {
		return CkMailMan_get_SocksVersion($this->_cPtr);
	}

	function put_SocksVersion($newVal) {
		CkMailMan_put_SocksVersion($this->_cPtr,$newVal);
	}

	function get_SoRcvBuf() {
		return CkMailMan_get_SoRcvBuf($this->_cPtr);
	}

	function put_SoRcvBuf($newVal) {
		CkMailMan_put_SoRcvBuf($this->_cPtr,$newVal);
	}

	function get_SoSndBuf() {
		return CkMailMan_get_SoSndBuf($this->_cPtr);
	}

	function put_SoSndBuf($newVal) {
		CkMailMan_put_SoSndBuf($this->_cPtr,$newVal);
	}

	function get_SslAllowedCiphers($str) {
		CkMailMan_get_SslAllowedCiphers($this->_cPtr,$str);
	}

	function sslAllowedCiphers() {
		return CkMailMan_sslAllowedCiphers($this->_cPtr);
	}

	function put_SslAllowedCiphers($newVal) {
		CkMailMan_put_SslAllowedCiphers($this->_cPtr,$newVal);
	}

	function get_SslProtocol($str) {
		CkMailMan_get_SslProtocol($this->_cPtr,$str);
	}

	function sslProtocol() {
		return CkMailMan_sslProtocol($this->_cPtr);
	}

	function put_SslProtocol($newVal) {
		CkMailMan_put_SslProtocol($this->_cPtr,$newVal);
	}

	function get_StartTLS() {
		return CkMailMan_get_StartTLS($this->_cPtr);
	}

	function put_StartTLS($newVal) {
		CkMailMan_put_StartTLS($this->_cPtr,$newVal);
	}

	function get_StartTLSifPossible() {
		return CkMailMan_get_StartTLSifPossible($this->_cPtr);
	}

	function put_StartTLSifPossible($newVal) {
		CkMailMan_put_StartTLSifPossible($this->_cPtr,$newVal);
	}

	function get_TlsCipherSuite($str) {
		CkMailMan_get_TlsCipherSuite($this->_cPtr,$str);
	}

	function tlsCipherSuite() {
		return CkMailMan_tlsCipherSuite($this->_cPtr);
	}

	function get_TlsPinSet($str) {
		CkMailMan_get_TlsPinSet($this->_cPtr,$str);
	}

	function tlsPinSet() {
		return CkMailMan_tlsPinSet($this->_cPtr);
	}

	function put_TlsPinSet($newVal) {
		CkMailMan_put_TlsPinSet($this->_cPtr,$newVal);
	}

	function get_TlsVersion($str) {
		CkMailMan_get_TlsVersion($this->_cPtr,$str);
	}

	function tlsVersion() {
		return CkMailMan_tlsVersion($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkMailMan_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkMailMan_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkMailMan_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UseApop() {
		return CkMailMan_get_UseApop($this->_cPtr);
	}

	function put_UseApop($newVal) {
		CkMailMan_put_UseApop($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkMailMan_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkMailMan_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkMailMan_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkMailMan_version($this->_cPtr);
	}

	function AddPfxSourceBd($bd,$password) {
		return CkMailMan_AddPfxSourceBd($this->_cPtr,$bd,$password);
	}

	function AddPfxSourceData($pfxData,$password) {
		return CkMailMan_AddPfxSourceData($this->_cPtr,$pfxData,$password);
	}

	function AddPfxSourceFile($pfxFilePath,$password) {
		return CkMailMan_AddPfxSourceFile($this->_cPtr,$pfxFilePath,$password);
	}

	function CheckMail() {
		return CkMailMan_CheckMail($this->_cPtr);
	}

	function CheckMailAsync() {
		$r=CkMailMan_CheckMailAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ClearBadEmailAddresses() {
		CkMailMan_ClearBadEmailAddresses($this->_cPtr);
	}

	function ClearPop3SessionLog() {
		CkMailMan_ClearPop3SessionLog($this->_cPtr);
	}

	function ClearSmtpSessionLog() {
		CkMailMan_ClearSmtpSessionLog($this->_cPtr);
	}

	function CloseSmtpConnection() {
		return CkMailMan_CloseSmtpConnection($this->_cPtr);
	}

	function CloseSmtpConnectionAsync() {
		$r=CkMailMan_CloseSmtpConnectionAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CopyMail() {
		$r=CkMailMan_CopyMail($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function CopyMailAsync() {
		$r=CkMailMan_CopyMailAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteBundle($emailBundle) {
		return CkMailMan_DeleteBundle($this->_cPtr,$emailBundle);
	}

	function DeleteBundleAsync($emailBundle) {
		$r=CkMailMan_DeleteBundleAsync($this->_cPtr,$emailBundle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteByMsgnum($msgnum) {
		return CkMailMan_DeleteByMsgnum($this->_cPtr,$msgnum);
	}

	function DeleteByMsgnumAsync($msgnum) {
		$r=CkMailMan_DeleteByMsgnumAsync($this->_cPtr,$msgnum);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteByUidl($uidl) {
		return CkMailMan_DeleteByUidl($this->_cPtr,$uidl);
	}

	function DeleteByUidlAsync($uidl) {
		$r=CkMailMan_DeleteByUidlAsync($this->_cPtr,$uidl);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteEmail($email) {
		return CkMailMan_DeleteEmail($this->_cPtr,$email);
	}

	function DeleteEmailAsync($email) {
		$r=CkMailMan_DeleteEmailAsync($this->_cPtr,$email);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteMultiple($uidlArray) {
		return CkMailMan_DeleteMultiple($this->_cPtr,$uidlArray);
	}

	function DeleteMultipleAsync($uidlArray) {
		$r=CkMailMan_DeleteMultipleAsync($this->_cPtr,$uidlArray);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DeleteUidlSet($stUidls) {
		return CkMailMan_DeleteUidlSet($this->_cPtr,$stUidls);
	}

	function DeleteUidlSetAsync($stUidls) {
		$r=CkMailMan_DeleteUidlSetAsync($this->_cPtr,$stUidls);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchAll($keepOnServer,$headersOnly,$numBodyLines,$bundle) {
		return CkMailMan_FetchAll($this->_cPtr,$keepOnServer,$headersOnly,$numBodyLines,$bundle);
	}

	function FetchAllAsync($keepOnServer,$headersOnly,$numBodyLines,$bundle) {
		$r=CkMailMan_FetchAllAsync($this->_cPtr,$keepOnServer,$headersOnly,$numBodyLines,$bundle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchByMsgnum($msgnum) {
		$r=CkMailMan_FetchByMsgnum($this->_cPtr,$msgnum);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function FetchByMsgnumAsync($msgnum) {
		$r=CkMailMan_FetchByMsgnumAsync($this->_cPtr,$msgnum);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchByUidl($uidl,$headerOnly,$numBodyLines,$email) {
		return CkMailMan_FetchByUidl($this->_cPtr,$uidl,$headerOnly,$numBodyLines,$email);
	}

	function FetchByUidlAsync($uidl,$headerOnly,$numBodyLines,$email) {
		$r=CkMailMan_FetchByUidlAsync($this->_cPtr,$uidl,$headerOnly,$numBodyLines,$email);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchEmail($uidl) {
		$r=CkMailMan_FetchEmail($this->_cPtr,$uidl);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function FetchEmailAsync($uidl) {
		$r=CkMailMan_FetchEmailAsync($this->_cPtr,$uidl);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchFull($partialEmail,$fullEmail) {
		return CkMailMan_FetchFull($this->_cPtr,$partialEmail,$fullEmail);
	}

	function FetchFullAsync($partialEmail,$fullEmail) {
		$r=CkMailMan_FetchFullAsync($this->_cPtr,$partialEmail,$fullEmail);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchMime($uidl,$outData) {
		return CkMailMan_FetchMime($this->_cPtr,$uidl,$outData);
	}

	function FetchMimeAsync($uidl) {
		$r=CkMailMan_FetchMimeAsync($this->_cPtr,$uidl);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchMimeBd($uidl,$mimeData) {
		return CkMailMan_FetchMimeBd($this->_cPtr,$uidl,$mimeData);
	}

	function FetchMimeBdAsync($uidl,$mimeData) {
		$r=CkMailMan_FetchMimeBdAsync($this->_cPtr,$uidl,$mimeData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchMimeByMsgnum($msgnum,$outBytes) {
		return CkMailMan_FetchMimeByMsgnum($this->_cPtr,$msgnum,$outBytes);
	}

	function FetchMimeByMsgnumAsync($msgnum) {
		$r=CkMailMan_FetchMimeByMsgnumAsync($this->_cPtr,$msgnum);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchMimeByMsgnumBd($msgnum,$bd) {
		return CkMailMan_FetchMimeByMsgnumBd($this->_cPtr,$msgnum,$bd);
	}

	function FetchMimeByMsgnumBdAsync($msgnum,$bd) {
		$r=CkMailMan_FetchMimeByMsgnumBdAsync($this->_cPtr,$msgnum,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchMultiple($uidlArray) {
		$r=CkMailMan_FetchMultiple($this->_cPtr,$uidlArray);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function FetchMultipleAsync($uidlArray) {
		$r=CkMailMan_FetchMultipleAsync($this->_cPtr,$uidlArray);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchMultipleHeaders($uidlArray,$numBodyLines) {
		$r=CkMailMan_FetchMultipleHeaders($this->_cPtr,$uidlArray,$numBodyLines);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function FetchMultipleHeadersAsync($uidlArray,$numBodyLines) {
		$r=CkMailMan_FetchMultipleHeadersAsync($this->_cPtr,$uidlArray,$numBodyLines);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchMultipleMime($uidlArray) {
		$r=CkMailMan_FetchMultipleMime($this->_cPtr,$uidlArray);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function FetchMultipleMimeAsync($uidlArray) {
		$r=CkMailMan_FetchMultipleMimeAsync($this->_cPtr,$uidlArray);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchOne($headerOnly,$numBodyLines,$msgNum,$email) {
		return CkMailMan_FetchOne($this->_cPtr,$headerOnly,$numBodyLines,$msgNum,$email);
	}

	function FetchOneAsync($headerOnly,$numBodyLines,$msgNum,$email) {
		$r=CkMailMan_FetchOneAsync($this->_cPtr,$headerOnly,$numBodyLines,$msgNum,$email);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchRange($keepOnServer,$headersOnly,$numBodyLines,$startIndex,$endIndex,$bundle) {
		return CkMailMan_FetchRange($this->_cPtr,$keepOnServer,$headersOnly,$numBodyLines,$startIndex,$endIndex,$bundle);
	}

	function FetchRangeAsync($keepOnServer,$headersOnly,$numBodyLines,$startIndex,$endIndex,$bundle) {
		$r=CkMailMan_FetchRangeAsync($this->_cPtr,$keepOnServer,$headersOnly,$numBodyLines,$startIndex,$endIndex,$bundle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchSingleHeader($numBodyLines,$messageNumber) {
		$r=CkMailMan_FetchSingleHeader($this->_cPtr,$numBodyLines,$messageNumber);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function FetchSingleHeaderAsync($numBodyLines,$messageNumber) {
		$r=CkMailMan_FetchSingleHeaderAsync($this->_cPtr,$numBodyLines,$messageNumber);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchSingleHeaderByUidl($numBodyLines,$uidl) {
		$r=CkMailMan_FetchSingleHeaderByUidl($this->_cPtr,$numBodyLines,$uidl);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function FetchSingleHeaderByUidlAsync($numBodyLines,$uidl) {
		$r=CkMailMan_FetchSingleHeaderByUidlAsync($this->_cPtr,$numBodyLines,$uidl);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchUidls($uidls) {
		return CkMailMan_FetchUidls($this->_cPtr,$uidls);
	}

	function FetchUidlsAsync($uidls) {
		$r=CkMailMan_FetchUidlsAsync($this->_cPtr,$uidls);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FetchUidlSet($uidls,$headersOnly,$numBodyLines,$bundle) {
		return CkMailMan_FetchUidlSet($this->_cPtr,$uidls,$headersOnly,$numBodyLines,$bundle);
	}

	function FetchUidlSetAsync($uidls,$headersOnly,$numBodyLines,$bundle) {
		$r=CkMailMan_FetchUidlSetAsync($this->_cPtr,$uidls,$headersOnly,$numBodyLines,$bundle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetAllHeaders($numBodyLines) {
		$r=CkMailMan_GetAllHeaders($this->_cPtr,$numBodyLines);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function GetAllHeadersAsync($numBodyLines) {
		$r=CkMailMan_GetAllHeadersAsync($this->_cPtr,$numBodyLines);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetBadEmailAddrs() {
		$r=CkMailMan_GetBadEmailAddrs($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function GetFullEmail($email) {
		$r=CkMailMan_GetFullEmail($this->_cPtr,$email);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function GetFullEmailAsync($email) {
		$r=CkMailMan_GetFullEmailAsync($this->_cPtr,$email);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetHeaders($numBodyLines,$fromIndex,$toIndex) {
		$r=CkMailMan_GetHeaders($this->_cPtr,$numBodyLines,$fromIndex,$toIndex);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function GetHeadersAsync($numBodyLines,$fromIndex,$toIndex) {
		$r=CkMailMan_GetHeadersAsync($this->_cPtr,$numBodyLines,$fromIndex,$toIndex);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetLastJsonData($json) {
		CkMailMan_GetLastJsonData($this->_cPtr,$json);
	}

	function GetMailboxCount() {
		return CkMailMan_GetMailboxCount($this->_cPtr);
	}

	function GetMailboxCountAsync() {
		$r=CkMailMan_GetMailboxCountAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getMailboxInfoXml() {
		return CkMailMan_getMailboxInfoXml($this->_cPtr);
	}

	function mailboxInfoXml() {
		return CkMailMan_mailboxInfoXml($this->_cPtr);
	}

	function GetMailboxInfoXmlAsync() {
		$r=CkMailMan_GetMailboxInfoXmlAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetMailboxSize() {
		return CkMailMan_GetMailboxSize($this->_cPtr);
	}

	function GetMailboxSizeAsync() {
		$r=CkMailMan_GetMailboxSizeAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetPop3SslServerCert() {
		$r=CkMailMan_GetPop3SslServerCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetSentToEmailAddrs() {
		$r=CkMailMan_GetSentToEmailAddrs($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function GetServerCert($useSmtp,$cert) {
		return CkMailMan_GetServerCert($this->_cPtr,$useSmtp,$cert);
	}

	function GetSizeByUidl($uidl) {
		return CkMailMan_GetSizeByUidl($this->_cPtr,$uidl);
	}

	function GetSizeByUidlAsync($uidl) {
		$r=CkMailMan_GetSizeByUidlAsync($this->_cPtr,$uidl);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetSmtpSslServerCert() {
		$r=CkMailMan_GetSmtpSslServerCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetUidls() {
		$r=CkMailMan_GetUidls($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function GetUidlsAsync() {
		$r=CkMailMan_GetUidlsAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function IsSmtpDsnCapable() {
		return CkMailMan_IsSmtpDsnCapable($this->_cPtr);
	}

	function IsSmtpDsnCapableAsync() {
		$r=CkMailMan_IsSmtpDsnCapableAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LastJsonData() {
		$r=CkMailMan_LastJsonData($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LoadEml($emlFilename) {
		$r=CkMailMan_LoadEml($this->_cPtr,$emlFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function LoadMbx($mbxFileName) {
		$r=CkMailMan_LoadMbx($this->_cPtr,$mbxFileName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function LoadMbxFile($mbxPath,$bundle) {
		return CkMailMan_LoadMbxFile($this->_cPtr,$mbxPath,$bundle);
	}

	function LoadMime($mimeText) {
		$r=CkMailMan_LoadMime($this->_cPtr,$mimeText);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkMailMan_LoadTaskCaller($this->_cPtr,$task);
	}

	function LoadXmlEmail($filename) {
		$r=CkMailMan_LoadXmlEmail($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function LoadXmlEmailString($xmlString) {
		$r=CkMailMan_LoadXmlEmailString($this->_cPtr,$xmlString);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmail($r);
		}
		return $r;
	}

	function LoadXmlFile($filename) {
		$r=CkMailMan_LoadXmlFile($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function LoadXmlString($xmlString) {
		$r=CkMailMan_LoadXmlString($this->_cPtr,$xmlString);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function mxLookup($emailAddress) {
		return CkMailMan_mxLookup($this->_cPtr,$emailAddress);
	}

	function MxLookupAll($emailAddress) {
		$r=CkMailMan_MxLookupAll($this->_cPtr,$emailAddress);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function OpenSmtpConnection() {
		return CkMailMan_OpenSmtpConnection($this->_cPtr);
	}

	function OpenSmtpConnectionAsync() {
		$r=CkMailMan_OpenSmtpConnectionAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Pop3Authenticate() {
		return CkMailMan_Pop3Authenticate($this->_cPtr);
	}

	function Pop3AuthenticateAsync() {
		$r=CkMailMan_Pop3AuthenticateAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Pop3BeginSession() {
		return CkMailMan_Pop3BeginSession($this->_cPtr);
	}

	function Pop3BeginSessionAsync() {
		$r=CkMailMan_Pop3BeginSessionAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Pop3Connect() {
		return CkMailMan_Pop3Connect($this->_cPtr);
	}

	function Pop3ConnectAsync() {
		$r=CkMailMan_Pop3ConnectAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Pop3EndSession() {
		return CkMailMan_Pop3EndSession($this->_cPtr);
	}

	function Pop3EndSessionAsync() {
		$r=CkMailMan_Pop3EndSessionAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Pop3EndSessionNoQuit() {
		return CkMailMan_Pop3EndSessionNoQuit($this->_cPtr);
	}

	function Pop3EndSessionNoQuitAsync() {
		$r=CkMailMan_Pop3EndSessionNoQuitAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Pop3Noop() {
		return CkMailMan_Pop3Noop($this->_cPtr);
	}

	function Pop3NoopAsync() {
		$r=CkMailMan_Pop3NoopAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Pop3Reset() {
		return CkMailMan_Pop3Reset($this->_cPtr);
	}

	function Pop3ResetAsync() {
		$r=CkMailMan_Pop3ResetAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function pop3SendRawCommand($command,$charset) {
		return CkMailMan_pop3SendRawCommand($this->_cPtr,$command,$charset);
	}

	function Pop3SendRawCommandAsync($command,$charset) {
		$r=CkMailMan_Pop3SendRawCommandAsync($this->_cPtr,$command,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QuickSend($fromAddr,$toAddr,$subject,$body,$smtpServer) {
		return CkMailMan_QuickSend($this->_cPtr,$fromAddr,$toAddr,$subject,$body,$smtpServer);
	}

	function QuickSendAsync($fromAddr,$toAddr,$subject,$body,$smtpServer) {
		$r=CkMailMan_QuickSendAsync($this->_cPtr,$fromAddr,$toAddr,$subject,$body,$smtpServer);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function renderToMime($email) {
		return CkMailMan_renderToMime($this->_cPtr,$email);
	}

	function RenderToMimeBd($email,$renderedMime) {
		return CkMailMan_RenderToMimeBd($this->_cPtr,$email,$renderedMime);
	}

	function RenderToMimeBytes($email,$outBytes) {
		return CkMailMan_RenderToMimeBytes($this->_cPtr,$email,$outBytes);
	}

	function RenderToMimeSb($email,$renderedMime) {
		return CkMailMan_RenderToMimeSb($this->_cPtr,$email,$renderedMime);
	}

	function SendBundle($bundle) {
		return CkMailMan_SendBundle($this->_cPtr,$bundle);
	}

	function SendBundleAsync($bundle) {
		$r=CkMailMan_SendBundleAsync($this->_cPtr,$bundle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendEmail($email) {
		return CkMailMan_SendEmail($this->_cPtr,$email);
	}

	function SendEmailAsync($email) {
		$r=CkMailMan_SendEmailAsync($this->_cPtr,$email);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendMime($fromAddr,$recipients,$mimeSource) {
		return CkMailMan_SendMime($this->_cPtr,$fromAddr,$recipients,$mimeSource);
	}

	function SendMimeAsync($fromAddr,$recipients,$mimeSource) {
		$r=CkMailMan_SendMimeAsync($this->_cPtr,$fromAddr,$recipients,$mimeSource);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendMimeBd($fromAddr,$recipients,$mimeData) {
		return CkMailMan_SendMimeBd($this->_cPtr,$fromAddr,$recipients,$mimeData);
	}

	function SendMimeBdAsync($fromAddr,$recipients,$mimeData) {
		$r=CkMailMan_SendMimeBdAsync($this->_cPtr,$fromAddr,$recipients,$mimeData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendMimeBytes($fromAddr,$recipients,$mimeSource) {
		return CkMailMan_SendMimeBytes($this->_cPtr,$fromAddr,$recipients,$mimeSource);
	}

	function SendMimeBytesAsync($fromAddr,$recipients,$mimeSource) {
		$r=CkMailMan_SendMimeBytesAsync($this->_cPtr,$fromAddr,$recipients,$mimeSource);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendMimeToList($fromAddr,$distListFilename,$mimeSource) {
		return CkMailMan_SendMimeToList($this->_cPtr,$fromAddr,$distListFilename,$mimeSource);
	}

	function SendMimeToListAsync($fromAddr,$distListFilename,$mimeSource) {
		$r=CkMailMan_SendMimeToListAsync($this->_cPtr,$fromAddr,$distListFilename,$mimeSource);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetDecryptCert($cert) {
		return CkMailMan_SetDecryptCert($this->_cPtr,$cert);
	}

	function SetDecryptCert2($cert,$privateKey) {
		return CkMailMan_SetDecryptCert2($this->_cPtr,$cert,$privateKey);
	}

	function SetPassword($protocol,$password) {
		return CkMailMan_SetPassword($this->_cPtr,$protocol,$password);
	}

	function SetSslClientCert($cert) {
		return CkMailMan_SetSslClientCert($this->_cPtr,$cert);
	}

	function SetSslClientCertPem($pemDataOrFilename,$pemPassword) {
		return CkMailMan_SetSslClientCertPem($this->_cPtr,$pemDataOrFilename,$pemPassword);
	}

	function SetSslClientCertPfx($pfxFilename,$pfxPassword) {
		return CkMailMan_SetSslClientCertPfx($this->_cPtr,$pfxFilename,$pfxPassword);
	}

	function SmtpAuthenticate() {
		return CkMailMan_SmtpAuthenticate($this->_cPtr);
	}

	function SmtpAuthenticateAsync() {
		$r=CkMailMan_SmtpAuthenticateAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SmtpConnect() {
		return CkMailMan_SmtpConnect($this->_cPtr);
	}

	function SmtpConnectAsync() {
		$r=CkMailMan_SmtpConnectAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SmtpNoop() {
		return CkMailMan_SmtpNoop($this->_cPtr);
	}

	function SmtpNoopAsync() {
		$r=CkMailMan_SmtpNoopAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SmtpReset() {
		return CkMailMan_SmtpReset($this->_cPtr);
	}

	function SmtpResetAsync() {
		$r=CkMailMan_SmtpResetAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function smtpSendRawCommand($command,$charset,$bEncodeBase64) {
		return CkMailMan_smtpSendRawCommand($this->_cPtr,$command,$charset,$bEncodeBase64);
	}

	function SmtpSendRawCommandAsync($command,$charset,$bEncodeBase64) {
		$r=CkMailMan_SmtpSendRawCommandAsync($this->_cPtr,$command,$charset,$bEncodeBase64);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshAuthenticatePk($sshLogin,$sshUsername) {
		return CkMailMan_SshAuthenticatePk($this->_cPtr,$sshLogin,$sshUsername);
	}

	function SshAuthenticatePkAsync($sshLogin,$sshUsername) {
		$r=CkMailMan_SshAuthenticatePkAsync($this->_cPtr,$sshLogin,$sshUsername);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshAuthenticatePw($sshLogin,$sshPassword) {
		return CkMailMan_SshAuthenticatePw($this->_cPtr,$sshLogin,$sshPassword);
	}

	function SshAuthenticatePwAsync($sshLogin,$sshPassword) {
		$r=CkMailMan_SshAuthenticatePwAsync($this->_cPtr,$sshLogin,$sshPassword);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshCloseTunnel() {
		return CkMailMan_SshCloseTunnel($this->_cPtr);
	}

	function SshCloseTunnelAsync() {
		$r=CkMailMan_SshCloseTunnelAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshOpenTunnel($sshHostname,$sshPort) {
		return CkMailMan_SshOpenTunnel($this->_cPtr,$sshHostname,$sshPort);
	}

	function SshOpenTunnelAsync($sshHostname,$sshPort) {
		$r=CkMailMan_SshOpenTunnelAsync($this->_cPtr,$sshHostname,$sshPort);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function TransferMail() {
		$r=CkMailMan_TransferMail($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkEmailBundle($r);
		}
		return $r;
	}

	function TransferMailAsync() {
		$r=CkMailMan_TransferMailAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function TransferMultipleMime($uidlArray) {
		$r=CkMailMan_TransferMultipleMime($this->_cPtr,$uidlArray);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function TransferMultipleMimeAsync($uidlArray) {
		$r=CkMailMan_TransferMultipleMimeAsync($this->_cPtr,$uidlArray);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UseCertVault($vault) {
		return CkMailMan_UseCertVault($this->_cPtr,$vault);
	}

	function UseSsh($ssh) {
		return CkMailMan_UseSsh($this->_cPtr,$ssh);
	}

	function UseSshTunnel($tunnel) {
		return CkMailMan_UseSshTunnel($this->_cPtr,$tunnel);
	}

	function VerifyPopConnection() {
		return CkMailMan_VerifyPopConnection($this->_cPtr);
	}

	function VerifyPopConnectionAsync() {
		$r=CkMailMan_VerifyPopConnectionAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function VerifyPopLogin() {
		return CkMailMan_VerifyPopLogin($this->_cPtr);
	}

	function VerifyPopLoginAsync() {
		$r=CkMailMan_VerifyPopLoginAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function VerifyRecips($email,$badAddrs) {
		return CkMailMan_VerifyRecips($this->_cPtr,$email,$badAddrs);
	}

	function VerifyRecipsAsync($email,$badAddrs) {
		$r=CkMailMan_VerifyRecipsAsync($this->_cPtr,$email,$badAddrs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function VerifySmtpConnection() {
		return CkMailMan_VerifySmtpConnection($this->_cPtr);
	}

	function VerifySmtpConnectionAsync() {
		$r=CkMailMan_VerifySmtpConnectionAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function VerifySmtpLogin() {
		return CkMailMan_VerifySmtpLogin($this->_cPtr);
	}

	function VerifySmtpLoginAsync() {
		$r=CkMailMan_VerifySmtpLoginAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkMailboxes {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkMailboxes') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkMailboxes();
	}

	function get_Utf8() {
		return CkMailboxes_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkMailboxes_put_Utf8($this->_cPtr,$b);
	}

	function get_Count() {
		return CkMailboxes_get_Count($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkMailboxes_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkMailboxes_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkMailboxes_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkMailboxes_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkMailboxes_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkMailboxes_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkMailboxes_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkMailboxes_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkMailboxes_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkMailboxes_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkMailboxes_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkMailboxes_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkMailboxes_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkMailboxes_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkMailboxes_version($this->_cPtr);
	}

	function getFlags($index) {
		return CkMailboxes_getFlags($this->_cPtr,$index);
	}

	function flags($index) {
		return CkMailboxes_flags($this->_cPtr,$index);
	}

	function GetMailboxIndex($mbxName) {
		return CkMailboxes_GetMailboxIndex($this->_cPtr,$mbxName);
	}

	function getName($index) {
		return CkMailboxes_getName($this->_cPtr,$index);
	}

	function name($index) {
		return CkMailboxes_name($this->_cPtr,$index);
	}

	function getNthFlag($index,$flagIndex) {
		return CkMailboxes_getNthFlag($this->_cPtr,$index,$flagIndex);
	}

	function nthFlag($index,$flagIndex) {
		return CkMailboxes_nthFlag($this->_cPtr,$index,$flagIndex);
	}

	function GetNumFlags($index) {
		return CkMailboxes_GetNumFlags($this->_cPtr,$index);
	}

	function HasFlag($index,$flagName) {
		return CkMailboxes_HasFlag($this->_cPtr,$index,$flagName);
	}

	function HasInferiors($index) {
		return CkMailboxes_HasInferiors($this->_cPtr,$index);
	}

	function IsMarked($index) {
		return CkMailboxes_IsMarked($this->_cPtr,$index);
	}

	function IsSelectable($index) {
		return CkMailboxes_IsSelectable($this->_cPtr,$index);
	}

	function LoadTaskResult($task) {
		return CkMailboxes_LoadTaskResult($this->_cPtr,$task);
	}
}

class CkMessageSet {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkMessageSet') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkMessageSet();
	}

	function get_Utf8() {
		return CkMessageSet_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkMessageSet_put_Utf8($this->_cPtr,$b);
	}

	function get_Count() {
		return CkMessageSet_get_Count($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkMessageSet_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkMessageSet_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkMessageSet_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_HasUids() {
		return CkMessageSet_get_HasUids($this->_cPtr);
	}

	function put_HasUids($newVal) {
		CkMessageSet_put_HasUids($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkMessageSet_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkMessageSet_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkMessageSet_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkMessageSet_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkMessageSet_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkMessageSet_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkMessageSet_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkMessageSet_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkMessageSet_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkMessageSet_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkMessageSet_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkMessageSet_version($this->_cPtr);
	}

	function ContainsId($msgId) {
		return CkMessageSet_ContainsId($this->_cPtr,$msgId);
	}

	function FromCompactString($str) {
		return CkMessageSet_FromCompactString($this->_cPtr,$str);
	}

	function GetId($index) {
		return CkMessageSet_GetId($this->_cPtr,$index);
	}

	function InsertId($id) {
		CkMessageSet_InsertId($this->_cPtr,$id);
	}

	function LoadTaskResult($task) {
		return CkMessageSet_LoadTaskResult($this->_cPtr,$task);
	}

	function RemoveId($id) {
		CkMessageSet_RemoveId($this->_cPtr,$id);
	}

	function Subtract($msgSet) {
		CkMessageSet_Subtract($this->_cPtr,$msgSet);
	}

	function toCommaSeparatedStr() {
		return CkMessageSet_toCommaSeparatedStr($this->_cPtr);
	}

	function toCompactString() {
		return CkMessageSet_toCompactString($this->_cPtr);
	}
}

class CkMht {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkMht') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkMht();
	}

	function get_Utf8() {
		return CkMht_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkMht_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkMht_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkMht_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkMht_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_BaseUrl($str) {
		CkMht_get_BaseUrl($this->_cPtr,$str);
	}

	function baseUrl() {
		return CkMht_baseUrl($this->_cPtr);
	}

	function put_BaseUrl($newVal) {
		CkMht_put_BaseUrl($this->_cPtr,$newVal);
	}

	function get_ConnectTimeout() {
		return CkMht_get_ConnectTimeout($this->_cPtr);
	}

	function put_ConnectTimeout($newVal) {
		CkMht_put_ConnectTimeout($this->_cPtr,$newVal);
	}

	function get_DebugHtmlAfter($str) {
		CkMht_get_DebugHtmlAfter($this->_cPtr,$str);
	}

	function debugHtmlAfter() {
		return CkMht_debugHtmlAfter($this->_cPtr);
	}

	function put_DebugHtmlAfter($newVal) {
		CkMht_put_DebugHtmlAfter($this->_cPtr,$newVal);
	}

	function get_DebugHtmlBefore($str) {
		CkMht_get_DebugHtmlBefore($this->_cPtr,$str);
	}

	function debugHtmlBefore() {
		return CkMht_debugHtmlBefore($this->_cPtr);
	}

	function put_DebugHtmlBefore($newVal) {
		CkMht_put_DebugHtmlBefore($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkMht_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkMht_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkMht_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EmbedImages() {
		return CkMht_get_EmbedImages($this->_cPtr);
	}

	function put_EmbedImages($newVal) {
		CkMht_put_EmbedImages($this->_cPtr,$newVal);
	}

	function get_EmbedLocalOnly() {
		return CkMht_get_EmbedLocalOnly($this->_cPtr);
	}

	function put_EmbedLocalOnly($newVal) {
		CkMht_put_EmbedLocalOnly($this->_cPtr,$newVal);
	}

	function get_FetchFromCache() {
		return CkMht_get_FetchFromCache($this->_cPtr);
	}

	function put_FetchFromCache($newVal) {
		CkMht_put_FetchFromCache($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkMht_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkMht_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_IgnoreMustRevalidate() {
		return CkMht_get_IgnoreMustRevalidate($this->_cPtr);
	}

	function put_IgnoreMustRevalidate($newVal) {
		CkMht_put_IgnoreMustRevalidate($this->_cPtr,$newVal);
	}

	function get_IgnoreNoCache() {
		return CkMht_get_IgnoreNoCache($this->_cPtr);
	}

	function put_IgnoreNoCache($newVal) {
		CkMht_put_IgnoreNoCache($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkMht_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkMht_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkMht_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkMht_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkMht_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkMht_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkMht_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkMht_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NoScripts() {
		return CkMht_get_NoScripts($this->_cPtr);
	}

	function put_NoScripts($newVal) {
		CkMht_put_NoScripts($this->_cPtr,$newVal);
	}

	function get_NtlmAuth() {
		return CkMht_get_NtlmAuth($this->_cPtr);
	}

	function put_NtlmAuth($newVal) {
		CkMht_put_NtlmAuth($this->_cPtr,$newVal);
	}

	function get_NumCacheLevels() {
		return CkMht_get_NumCacheLevels($this->_cPtr);
	}

	function put_NumCacheLevels($newVal) {
		CkMht_put_NumCacheLevels($this->_cPtr,$newVal);
	}

	function get_NumCacheRoots() {
		return CkMht_get_NumCacheRoots($this->_cPtr);
	}

	function get_PreferIpv6() {
		return CkMht_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkMht_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_PreferMHTScripts() {
		return CkMht_get_PreferMHTScripts($this->_cPtr);
	}

	function put_PreferMHTScripts($newVal) {
		CkMht_put_PreferMHTScripts($this->_cPtr,$newVal);
	}

	function get_Proxy($str) {
		CkMht_get_Proxy($this->_cPtr,$str);
	}

	function proxy() {
		return CkMht_proxy($this->_cPtr);
	}

	function put_Proxy($newVal) {
		CkMht_put_Proxy($this->_cPtr,$newVal);
	}

	function get_ProxyLogin($str) {
		CkMht_get_ProxyLogin($this->_cPtr,$str);
	}

	function proxyLogin() {
		return CkMht_proxyLogin($this->_cPtr);
	}

	function put_ProxyLogin($newVal) {
		CkMht_put_ProxyLogin($this->_cPtr,$newVal);
	}

	function get_ProxyPassword($str) {
		CkMht_get_ProxyPassword($this->_cPtr,$str);
	}

	function proxyPassword() {
		return CkMht_proxyPassword($this->_cPtr);
	}

	function put_ProxyPassword($newVal) {
		CkMht_put_ProxyPassword($this->_cPtr,$newVal);
	}

	function get_ReadTimeout() {
		return CkMht_get_ReadTimeout($this->_cPtr);
	}

	function put_ReadTimeout($newVal) {
		CkMht_put_ReadTimeout($this->_cPtr,$newVal);
	}

	function get_RequireSslCertVerify() {
		return CkMht_get_RequireSslCertVerify($this->_cPtr);
	}

	function put_RequireSslCertVerify($newVal) {
		CkMht_put_RequireSslCertVerify($this->_cPtr,$newVal);
	}

	function get_SocksHostname($str) {
		CkMht_get_SocksHostname($this->_cPtr,$str);
	}

	function socksHostname() {
		return CkMht_socksHostname($this->_cPtr);
	}

	function put_SocksHostname($newVal) {
		CkMht_put_SocksHostname($this->_cPtr,$newVal);
	}

	function get_SocksPassword($str) {
		CkMht_get_SocksPassword($this->_cPtr,$str);
	}

	function socksPassword() {
		return CkMht_socksPassword($this->_cPtr);
	}

	function put_SocksPassword($newVal) {
		CkMht_put_SocksPassword($this->_cPtr,$newVal);
	}

	function get_SocksPort() {
		return CkMht_get_SocksPort($this->_cPtr);
	}

	function put_SocksPort($newVal) {
		CkMht_put_SocksPort($this->_cPtr,$newVal);
	}

	function get_SocksUsername($str) {
		CkMht_get_SocksUsername($this->_cPtr,$str);
	}

	function socksUsername() {
		return CkMht_socksUsername($this->_cPtr);
	}

	function put_SocksUsername($newVal) {
		CkMht_put_SocksUsername($this->_cPtr,$newVal);
	}

	function get_SocksVersion() {
		return CkMht_get_SocksVersion($this->_cPtr);
	}

	function put_SocksVersion($newVal) {
		CkMht_put_SocksVersion($this->_cPtr,$newVal);
	}

	function get_UnpackDirect() {
		return CkMht_get_UnpackDirect($this->_cPtr);
	}

	function put_UnpackDirect($newVal) {
		CkMht_put_UnpackDirect($this->_cPtr,$newVal);
	}

	function get_UnpackUseRelPaths() {
		return CkMht_get_UnpackUseRelPaths($this->_cPtr);
	}

	function put_UnpackUseRelPaths($newVal) {
		CkMht_put_UnpackUseRelPaths($this->_cPtr,$newVal);
	}

	function get_UpdateCache() {
		return CkMht_get_UpdateCache($this->_cPtr);
	}

	function put_UpdateCache($newVal) {
		CkMht_put_UpdateCache($this->_cPtr,$newVal);
	}

	function get_UseCids() {
		return CkMht_get_UseCids($this->_cPtr);
	}

	function put_UseCids($newVal) {
		CkMht_put_UseCids($this->_cPtr,$newVal);
	}

	function get_UseFilename() {
		return CkMht_get_UseFilename($this->_cPtr);
	}

	function put_UseFilename($newVal) {
		CkMht_put_UseFilename($this->_cPtr,$newVal);
	}

	function get_UseIEProxy() {
		return CkMht_get_UseIEProxy($this->_cPtr);
	}

	function put_UseIEProxy($newVal) {
		CkMht_put_UseIEProxy($this->_cPtr,$newVal);
	}

	function get_UseInline() {
		return CkMht_get_UseInline($this->_cPtr);
	}

	function put_UseInline($newVal) {
		CkMht_put_UseInline($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkMht_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkMht_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkMht_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkMht_version($this->_cPtr);
	}

	function get_WebSiteLogin($str) {
		CkMht_get_WebSiteLogin($this->_cPtr,$str);
	}

	function webSiteLogin() {
		return CkMht_webSiteLogin($this->_cPtr);
	}

	function put_WebSiteLogin($newVal) {
		CkMht_put_WebSiteLogin($this->_cPtr,$newVal);
	}

	function get_WebSiteLoginDomain($str) {
		CkMht_get_WebSiteLoginDomain($this->_cPtr,$str);
	}

	function webSiteLoginDomain() {
		return CkMht_webSiteLoginDomain($this->_cPtr);
	}

	function put_WebSiteLoginDomain($newVal) {
		CkMht_put_WebSiteLoginDomain($this->_cPtr,$newVal);
	}

	function get_WebSitePassword($str) {
		CkMht_get_WebSitePassword($this->_cPtr,$str);
	}

	function webSitePassword() {
		return CkMht_webSitePassword($this->_cPtr);
	}

	function put_WebSitePassword($newVal) {
		CkMht_put_WebSitePassword($this->_cPtr,$newVal);
	}

	function AddCacheRoot($dir) {
		CkMht_AddCacheRoot($this->_cPtr,$dir);
	}

	function AddCustomHeader($name,$value) {
		CkMht_AddCustomHeader($this->_cPtr,$name,$value);
	}

	function AddExternalStyleSheet($url) {
		CkMht_AddExternalStyleSheet($this->_cPtr,$url);
	}

	function ClearCustomHeaders() {
		CkMht_ClearCustomHeaders($this->_cPtr);
	}

	function ExcludeImagesMatching($pattern) {
		CkMht_ExcludeImagesMatching($this->_cPtr,$pattern);
	}

	function GetAndSaveEML($url_or_htmlFilepath,$emlPath) {
		return CkMht_GetAndSaveEML($this->_cPtr,$url_or_htmlFilepath,$emlPath);
	}

	function GetAndSaveEMLAsync($url_or_htmlFilepath,$emlPath) {
		$r=CkMht_GetAndSaveEMLAsync($this->_cPtr,$url_or_htmlFilepath,$emlPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetAndSaveMHT($url_or_htmlFilepath,$mhtPath) {
		return CkMht_GetAndSaveMHT($this->_cPtr,$url_or_htmlFilepath,$mhtPath);
	}

	function GetAndSaveMHTAsync($url_or_htmlFilepath,$mhtPath) {
		$r=CkMht_GetAndSaveMHTAsync($this->_cPtr,$url_or_htmlFilepath,$mhtPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetAndZipEML($url_or_htmlFilepath,$zipEntryFilename,$zipFilename) {
		return CkMht_GetAndZipEML($this->_cPtr,$url_or_htmlFilepath,$zipEntryFilename,$zipFilename);
	}

	function GetAndZipEMLAsync($url_or_htmlFilepath,$zipEntryFilename,$zipFilename) {
		$r=CkMht_GetAndZipEMLAsync($this->_cPtr,$url_or_htmlFilepath,$zipEntryFilename,$zipFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetAndZipMHT($url_or_htmlFilepath,$zipEntryFilename,$zipFilename) {
		return CkMht_GetAndZipMHT($this->_cPtr,$url_or_htmlFilepath,$zipEntryFilename,$zipFilename);
	}

	function GetAndZipMHTAsync($url_or_htmlFilepath,$zipEntryFilename,$zipFilename) {
		$r=CkMht_GetAndZipMHTAsync($this->_cPtr,$url_or_htmlFilepath,$zipEntryFilename,$zipFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getCacheRoot($index) {
		return CkMht_getCacheRoot($this->_cPtr,$index);
	}

	function cacheRoot($index) {
		return CkMht_cacheRoot($this->_cPtr,$index);
	}

	function getEML($url_or_htmlFilepath) {
		return CkMht_getEML($this->_cPtr,$url_or_htmlFilepath);
	}

	function eML($url_or_htmlFilepath) {
		return CkMht_eML($this->_cPtr,$url_or_htmlFilepath);
	}

	function GetEMLAsync($url_or_htmlFilepath) {
		$r=CkMht_GetEMLAsync($this->_cPtr,$url_or_htmlFilepath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getMHT($url_or_htmlFilepath) {
		return CkMht_getMHT($this->_cPtr,$url_or_htmlFilepath);
	}

	function mHT($url_or_htmlFilepath) {
		return CkMht_mHT($this->_cPtr,$url_or_htmlFilepath);
	}

	function GetMHTAsync($url_or_htmlFilepath) {
		$r=CkMht_GetMHTAsync($this->_cPtr,$url_or_htmlFilepath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function htmlToEML($htmlText) {
		return CkMht_htmlToEML($this->_cPtr,$htmlText);
	}

	function HtmlToEMLAsync($htmlText) {
		$r=CkMht_HtmlToEMLAsync($this->_cPtr,$htmlText);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HtmlToEMLFile($html,$emlFilename) {
		return CkMht_HtmlToEMLFile($this->_cPtr,$html,$emlFilename);
	}

	function HtmlToEMLFileAsync($html,$emlFilename) {
		$r=CkMht_HtmlToEMLFileAsync($this->_cPtr,$html,$emlFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function htmlToMHT($htmlText) {
		return CkMht_htmlToMHT($this->_cPtr,$htmlText);
	}

	function HtmlToMHTAsync($htmlText) {
		$r=CkMht_HtmlToMHTAsync($this->_cPtr,$htmlText);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function HtmlToMHTFile($html,$mhtFilename) {
		return CkMht_HtmlToMHTFile($this->_cPtr,$html,$mhtFilename);
	}

	function HtmlToMHTFileAsync($html,$mhtFilename) {
		$r=CkMht_HtmlToMHTFileAsync($this->_cPtr,$html,$mhtFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkMht_LoadTaskCaller($this->_cPtr,$task);
	}

	function RemoveCustomHeader($name) {
		CkMht_RemoveCustomHeader($this->_cPtr,$name);
	}

	function RestoreDefaults() {
		CkMht_RestoreDefaults($this->_cPtr);
	}

	function UnpackMHT($mhtFilename,$unpackDir,$htmlFilename,$partsSubDir) {
		return CkMht_UnpackMHT($this->_cPtr,$mhtFilename,$unpackDir,$htmlFilename,$partsSubDir);
	}

	function UnpackMHTString($mhtString,$unpackDir,$htmlFilename,$partsSubDir) {
		return CkMht_UnpackMHTString($this->_cPtr,$mhtString,$unpackDir,$htmlFilename,$partsSubDir);
	}
}

class CkMime {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkMime') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkMime();
	}

	function get_Utf8() {
		return CkMime_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkMime_put_Utf8($this->_cPtr,$b);
	}

	function get_Boundary($str) {
		CkMime_get_Boundary($this->_cPtr,$str);
	}

	function boundary() {
		return CkMime_boundary($this->_cPtr);
	}

	function put_Boundary($newVal) {
		CkMime_put_Boundary($this->_cPtr,$newVal);
	}

	function get_Charset($str) {
		CkMime_get_Charset($this->_cPtr,$str);
	}

	function charset() {
		return CkMime_charset($this->_cPtr);
	}

	function put_Charset($newVal) {
		CkMime_put_Charset($this->_cPtr,$newVal);
	}

	function get_CmsOptions($str) {
		CkMime_get_CmsOptions($this->_cPtr,$str);
	}

	function cmsOptions() {
		return CkMime_cmsOptions($this->_cPtr);
	}

	function put_CmsOptions($newVal) {
		CkMime_put_CmsOptions($this->_cPtr,$newVal);
	}

	function get_ContentType($str) {
		CkMime_get_ContentType($this->_cPtr,$str);
	}

	function contentType() {
		return CkMime_contentType($this->_cPtr);
	}

	function put_ContentType($newVal) {
		CkMime_put_ContentType($this->_cPtr,$newVal);
	}

	function get_CurrentDateTime($str) {
		CkMime_get_CurrentDateTime($this->_cPtr,$str);
	}

	function currentDateTime() {
		return CkMime_currentDateTime($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkMime_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkMime_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkMime_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Disposition($str) {
		CkMime_get_Disposition($this->_cPtr,$str);
	}

	function disposition() {
		return CkMime_disposition($this->_cPtr);
	}

	function put_Disposition($newVal) {
		CkMime_put_Disposition($this->_cPtr,$newVal);
	}

	function get_Encoding($str) {
		CkMime_get_Encoding($this->_cPtr,$str);
	}

	function encoding() {
		return CkMime_encoding($this->_cPtr);
	}

	function put_Encoding($newVal) {
		CkMime_put_Encoding($this->_cPtr,$newVal);
	}

	function get_Filename($str) {
		CkMime_get_Filename($this->_cPtr,$str);
	}

	function filename() {
		return CkMime_filename($this->_cPtr);
	}

	function put_Filename($newVal) {
		CkMime_put_Filename($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkMime_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkMime_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkMime_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkMime_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkMime_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkMime_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkMime_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkMime_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Micalg($str) {
		CkMime_get_Micalg($this->_cPtr,$str);
	}

	function micalg() {
		return CkMime_micalg($this->_cPtr);
	}

	function put_Micalg($newVal) {
		CkMime_put_Micalg($this->_cPtr,$newVal);
	}

	function get_Name($str) {
		CkMime_get_Name($this->_cPtr,$str);
	}

	function name() {
		return CkMime_name($this->_cPtr);
	}

	function put_Name($newVal) {
		CkMime_put_Name($this->_cPtr,$newVal);
	}

	function get_NumDecryptCerts() {
		return CkMime_get_NumDecryptCerts($this->_cPtr);
	}

	function get_NumEncryptCerts() {
		return CkMime_get_NumEncryptCerts($this->_cPtr);
	}

	function get_NumHeaderFields() {
		return CkMime_get_NumHeaderFields($this->_cPtr);
	}

	function get_NumParts() {
		return CkMime_get_NumParts($this->_cPtr);
	}

	function get_NumSignerCerts() {
		return CkMime_get_NumSignerCerts($this->_cPtr);
	}

	function get_OaepHash($str) {
		CkMime_get_OaepHash($this->_cPtr,$str);
	}

	function oaepHash() {
		return CkMime_oaepHash($this->_cPtr);
	}

	function put_OaepHash($newVal) {
		CkMime_put_OaepHash($this->_cPtr,$newVal);
	}

	function get_OaepMgfHash($str) {
		CkMime_get_OaepMgfHash($this->_cPtr,$str);
	}

	function oaepMgfHash() {
		return CkMime_oaepMgfHash($this->_cPtr);
	}

	function put_OaepMgfHash($newVal) {
		CkMime_put_OaepMgfHash($this->_cPtr,$newVal);
	}

	function get_OaepPadding() {
		return CkMime_get_OaepPadding($this->_cPtr);
	}

	function put_OaepPadding($newVal) {
		CkMime_put_OaepPadding($this->_cPtr,$newVal);
	}

	function get_Pkcs7CryptAlg($str) {
		CkMime_get_Pkcs7CryptAlg($this->_cPtr,$str);
	}

	function pkcs7CryptAlg() {
		return CkMime_pkcs7CryptAlg($this->_cPtr);
	}

	function put_Pkcs7CryptAlg($newVal) {
		CkMime_put_Pkcs7CryptAlg($this->_cPtr,$newVal);
	}

	function get_Pkcs7KeyLength() {
		return CkMime_get_Pkcs7KeyLength($this->_cPtr);
	}

	function put_Pkcs7KeyLength($newVal) {
		CkMime_put_Pkcs7KeyLength($this->_cPtr,$newVal);
	}

	function get_Protocol($str) {
		CkMime_get_Protocol($this->_cPtr,$str);
	}

	function protocol() {
		return CkMime_protocol($this->_cPtr);
	}

	function put_Protocol($newVal) {
		CkMime_put_Protocol($this->_cPtr,$newVal);
	}

	function get_SigningAlg($str) {
		CkMime_get_SigningAlg($this->_cPtr,$str);
	}

	function signingAlg() {
		return CkMime_signingAlg($this->_cPtr);
	}

	function put_SigningAlg($newVal) {
		CkMime_put_SigningAlg($this->_cPtr,$newVal);
	}

	function get_SigningHashAlg($str) {
		CkMime_get_SigningHashAlg($this->_cPtr,$str);
	}

	function signingHashAlg() {
		return CkMime_signingHashAlg($this->_cPtr);
	}

	function put_SigningHashAlg($newVal) {
		CkMime_put_SigningHashAlg($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkMime_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkMime_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkMime_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UnwrapExtras() {
		return CkMime_get_UnwrapExtras($this->_cPtr);
	}

	function put_UnwrapExtras($newVal) {
		CkMime_put_UnwrapExtras($this->_cPtr,$newVal);
	}

	function get_UseMmDescription() {
		return CkMime_get_UseMmDescription($this->_cPtr);
	}

	function put_UseMmDescription($newVal) {
		CkMime_put_UseMmDescription($this->_cPtr,$newVal);
	}

	function get_UseXPkcs7() {
		return CkMime_get_UseXPkcs7($this->_cPtr);
	}

	function put_UseXPkcs7($newVal) {
		CkMime_put_UseXPkcs7($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkMime_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkMime_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkMime_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkMime_version($this->_cPtr);
	}

	function AddContentLength() {
		CkMime_AddContentLength($this->_cPtr);
	}

	function AddDecryptCert($cert) {
		return CkMime_AddDecryptCert($this->_cPtr,$cert);
	}

	function AddDetachedSignature($cert) {
		return CkMime_AddDetachedSignature($this->_cPtr,$cert);
	}

	function AddDetachedSignature2($cert,$transferHeaderFields) {
		return CkMime_AddDetachedSignature2($this->_cPtr,$cert,$transferHeaderFields);
	}

	function AddDetachedSignaturePk($cert,$privateKey) {
		return CkMime_AddDetachedSignaturePk($this->_cPtr,$cert,$privateKey);
	}

	function AddDetachedSignaturePk2($cert,$privateKey,$transferHeaderFields) {
		return CkMime_AddDetachedSignaturePk2($this->_cPtr,$cert,$privateKey,$transferHeaderFields);
	}

	function AddEncryptCert($cert) {
		return CkMime_AddEncryptCert($this->_cPtr,$cert);
	}

	function AddHeaderField($name,$value) {
		return CkMime_AddHeaderField($this->_cPtr,$name,$value);
	}

	function AddPfxSourceBd($bd,$password) {
		return CkMime_AddPfxSourceBd($this->_cPtr,$bd,$password);
	}

	function AddPfxSourceData($pfxFileData,$pfxPassword) {
		return CkMime_AddPfxSourceData($this->_cPtr,$pfxFileData,$pfxPassword);
	}

	function AddPfxSourceFile($pfxFilePath,$password) {
		return CkMime_AddPfxSourceFile($this->_cPtr,$pfxFilePath,$password);
	}

	function AppendPart($mime) {
		return CkMime_AppendPart($this->_cPtr,$mime);
	}

	function AppendPartFromFile($filename) {
		return CkMime_AppendPartFromFile($this->_cPtr,$filename);
	}

	function asnBodyToXml() {
		return CkMime_asnBodyToXml($this->_cPtr);
	}

	function ClearEncryptCerts() {
		CkMime_ClearEncryptCerts($this->_cPtr);
	}

	function ContainsEncryptedParts() {
		return CkMime_ContainsEncryptedParts($this->_cPtr);
	}

	function ContainsSignedParts() {
		return CkMime_ContainsSignedParts($this->_cPtr);
	}

	function Convert8Bit() {
		CkMime_Convert8Bit($this->_cPtr);
	}

	function ConvertToMultipartAlt() {
		return CkMime_ConvertToMultipartAlt($this->_cPtr);
	}

	function ConvertToMultipartMixed() {
		return CkMime_ConvertToMultipartMixed($this->_cPtr);
	}

	function ConvertToSigned($cert) {
		return CkMime_ConvertToSigned($this->_cPtr,$cert);
	}

	function ConvertToSignedPk($cert,$privateKey) {
		return CkMime_ConvertToSignedPk($this->_cPtr,$cert,$privateKey);
	}

	function Decrypt() {
		return CkMime_Decrypt($this->_cPtr);
	}

	function Decrypt2($cert,$privateKey) {
		return CkMime_Decrypt2($this->_cPtr,$cert,$privateKey);
	}

	function DecryptUsingCert($cert) {
		return CkMime_DecryptUsingCert($this->_cPtr,$cert);
	}

	function DecryptUsingPfxData($pfxData,$password) {
		return CkMime_DecryptUsingPfxData($this->_cPtr,$pfxData,$password);
	}

	function DecryptUsingPfxFile($pfxFilePath,$pfxPassword) {
		return CkMime_DecryptUsingPfxFile($this->_cPtr,$pfxFilePath,$pfxPassword);
	}

	function Encrypt($cert) {
		return CkMime_Encrypt($this->_cPtr,$cert);
	}

	function EncryptN() {
		return CkMime_EncryptN($this->_cPtr);
	}

	function ExtractPartsToFiles($dirPath) {
		$r=CkMime_ExtractPartsToFiles($this->_cPtr,$dirPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function FindIssuer($cert) {
		$r=CkMime_FindIssuer($this->_cPtr,$cert);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetBodyBd($binDat) {
		return CkMime_GetBodyBd($this->_cPtr,$binDat);
	}

	function GetBodyBinary($outData) {
		return CkMime_GetBodyBinary($this->_cPtr,$outData);
	}

	function getBodyDecoded() {
		return CkMime_getBodyDecoded($this->_cPtr);
	}

	function bodyDecoded() {
		return CkMime_bodyDecoded($this->_cPtr);
	}

	function getBodyEncoded() {
		return CkMime_getBodyEncoded($this->_cPtr);
	}

	function bodyEncoded() {
		return CkMime_bodyEncoded($this->_cPtr);
	}

	function GetEncryptCert($index) {
		$r=CkMime_GetEncryptCert($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function getEntireBody() {
		return CkMime_getEntireBody($this->_cPtr);
	}

	function entireBody() {
		return CkMime_entireBody($this->_cPtr);
	}

	function getEntireHead() {
		return CkMime_getEntireHead($this->_cPtr);
	}

	function entireHead() {
		return CkMime_entireHead($this->_cPtr);
	}

	function getHeaderField($fieldName) {
		return CkMime_getHeaderField($this->_cPtr,$fieldName);
	}

	function headerField($fieldName) {
		return CkMime_headerField($this->_cPtr,$fieldName);
	}

	function getHeaderFieldAttribute($name,$attrName) {
		return CkMime_getHeaderFieldAttribute($this->_cPtr,$name,$attrName);
	}

	function headerFieldAttribute($name,$attrName) {
		return CkMime_headerFieldAttribute($this->_cPtr,$name,$attrName);
	}

	function getHeaderFieldName($index) {
		return CkMime_getHeaderFieldName($this->_cPtr,$index);
	}

	function headerFieldName($index) {
		return CkMime_headerFieldName($this->_cPtr,$index);
	}

	function getHeaderFieldValue($index) {
		return CkMime_getHeaderFieldValue($this->_cPtr,$index);
	}

	function headerFieldValue($index) {
		return CkMime_headerFieldValue($this->_cPtr,$index);
	}

	function GetLastJsonData($json) {
		CkMime_GetLastJsonData($this->_cPtr,$json);
	}

	function getMime() {
		return CkMime_getMime($this->_cPtr);
	}

	function mime() {
		return CkMime_mime($this->_cPtr);
	}

	function GetMimeBd($bindat) {
		return CkMime_GetMimeBd($this->_cPtr,$bindat);
	}

	function GetMimeBytes($outBytes) {
		return CkMime_GetMimeBytes($this->_cPtr,$outBytes);
	}

	function GetMimeSb($sb) {
		return CkMime_GetMimeSb($this->_cPtr,$sb);
	}

	function GetPart($index) {
		$r=CkMime_GetPart($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkMime($r);
		}
		return $r;
	}

	function getSignatureSigningTimeStr($index) {
		return CkMime_getSignatureSigningTimeStr($this->_cPtr,$index);
	}

	function signatureSigningTimeStr($index) {
		return CkMime_signatureSigningTimeStr($this->_cPtr,$index);
	}

	function GetSignerCert($index) {
		$r=CkMime_GetSignerCert($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetSignerCertChain($index) {
		$r=CkMime_GetSignerCertChain($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCertChain($r);
		}
		return $r;
	}

	function getStructure($fmt) {
		return CkMime_getStructure($this->_cPtr,$fmt);
	}

	function structure($fmt) {
		return CkMime_structure($this->_cPtr,$fmt);
	}

	function getXml() {
		return CkMime_getXml($this->_cPtr);
	}

	function xml() {
		return CkMime_xml($this->_cPtr);
	}

	function HasSignatureSigningTime($index) {
		return CkMime_HasSignatureSigningTime($this->_cPtr,$index);
	}

	function IsApplicationData() {
		return CkMime_IsApplicationData($this->_cPtr);
	}

	function IsAttachment() {
		return CkMime_IsAttachment($this->_cPtr);
	}

	function IsAudio() {
		return CkMime_IsAudio($this->_cPtr);
	}

	function IsEncrypted() {
		return CkMime_IsEncrypted($this->_cPtr);
	}

	function IsHtml() {
		return CkMime_IsHtml($this->_cPtr);
	}

	function IsImage() {
		return CkMime_IsImage($this->_cPtr);
	}

	function IsMultipart() {
		return CkMime_IsMultipart($this->_cPtr);
	}

	function IsMultipartAlternative() {
		return CkMime_IsMultipartAlternative($this->_cPtr);
	}

	function IsMultipartMixed() {
		return CkMime_IsMultipartMixed($this->_cPtr);
	}

	function IsMultipartRelated() {
		return CkMime_IsMultipartRelated($this->_cPtr);
	}

	function IsPlainText() {
		return CkMime_IsPlainText($this->_cPtr);
	}

	function IsSigned() {
		return CkMime_IsSigned($this->_cPtr);
	}

	function IsText() {
		return CkMime_IsText($this->_cPtr);
	}

	function IsVideo() {
		return CkMime_IsVideo($this->_cPtr);
	}

	function IsXml() {
		return CkMime_IsXml($this->_cPtr);
	}

	function LastDecryptCert($index,$cert) {
		return CkMime_LastDecryptCert($this->_cPtr,$index,$cert);
	}

	function LastJsonData() {
		$r=CkMime_LastJsonData($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LastSignerCert($index,$cert) {
		return CkMime_LastSignerCert($this->_cPtr,$index,$cert);
	}

	function LoadMime($mimeMsg) {
		return CkMime_LoadMime($this->_cPtr,$mimeMsg);
	}

	function LoadMimeBd($bindat) {
		return CkMime_LoadMimeBd($this->_cPtr,$bindat);
	}

	function LoadMimeBytes($binData) {
		return CkMime_LoadMimeBytes($this->_cPtr,$binData);
	}

	function LoadMimeFile($fileName) {
		return CkMime_LoadMimeFile($this->_cPtr,$fileName);
	}

	function LoadMimeSb($sb) {
		return CkMime_LoadMimeSb($this->_cPtr,$sb);
	}

	function LoadXml($xml) {
		return CkMime_LoadXml($this->_cPtr,$xml);
	}

	function LoadXmlFile($fileName) {
		return CkMime_LoadXmlFile($this->_cPtr,$fileName);
	}

	function NewMessageRfc822($mimeObject) {
		return CkMime_NewMessageRfc822($this->_cPtr,$mimeObject);
	}

	function NewMultipartAlternative() {
		return CkMime_NewMultipartAlternative($this->_cPtr);
	}

	function NewMultipartMixed() {
		return CkMime_NewMultipartMixed($this->_cPtr);
	}

	function NewMultipartRelated() {
		return CkMime_NewMultipartRelated($this->_cPtr);
	}

	function PartAt($index,$subPart) {
		return CkMime_PartAt($this->_cPtr,$index,$subPart);
	}

	function PartsToFiles($path,$st) {
		return CkMime_PartsToFiles($this->_cPtr,$path,$st);
	}

	function RemoveHeaderField($fieldName,$bAllOccurrences) {
		CkMime_RemoveHeaderField($this->_cPtr,$fieldName,$bAllOccurrences);
	}

	function RemovePart($index) {
		return CkMime_RemovePart($this->_cPtr,$index);
	}

	function SaveBody($filename) {
		return CkMime_SaveBody($this->_cPtr,$filename);
	}

	function SaveMime($filename) {
		return CkMime_SaveMime($this->_cPtr,$filename);
	}

	function SaveXml($filename) {
		return CkMime_SaveXml($this->_cPtr,$filename);
	}

	function SetBody($str) {
		CkMime_SetBody($this->_cPtr,$str);
	}

	function SetBodyBd($bd) {
		return CkMime_SetBodyBd($this->_cPtr,$bd);
	}

	function SetBodyFromBinary($binData) {
		return CkMime_SetBodyFromBinary($this->_cPtr,$binData);
	}

	function SetBodyFromEncoded($encoding,$str) {
		return CkMime_SetBodyFromEncoded($this->_cPtr,$encoding,$str);
	}

	function SetBodyFromFile($fileName) {
		return CkMime_SetBodyFromFile($this->_cPtr,$fileName);
	}

	function SetBodyFromHtml($str) {
		return CkMime_SetBodyFromHtml($this->_cPtr,$str);
	}

	function SetBodyFromPlainText($str) {
		return CkMime_SetBodyFromPlainText($this->_cPtr,$str);
	}

	function SetBodyFromXml($str) {
		return CkMime_SetBodyFromXml($this->_cPtr,$str);
	}

	function SetHeaderField($name,$value) {
		return CkMime_SetHeaderField($this->_cPtr,$name,$value);
	}

	function SetVerifyCert($cert) {
		return CkMime_SetVerifyCert($this->_cPtr,$cert);
	}

	function UnwrapSecurity() {
		return CkMime_UnwrapSecurity($this->_cPtr);
	}

	function UrlEncodeBody($charset) {
		CkMime_UrlEncodeBody($this->_cPtr,$charset);
	}

	function UseCertVault($vault) {
		return CkMime_UseCertVault($this->_cPtr,$vault);
	}

	function Verify() {
		return CkMime_Verify($this->_cPtr);
	}
}

class CkNtlm {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkNtlm') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkNtlm();
	}

	function get_Utf8() {
		return CkNtlm_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkNtlm_put_Utf8($this->_cPtr,$b);
	}

	function get_ClientChallenge($str) {
		CkNtlm_get_ClientChallenge($this->_cPtr,$str);
	}

	function clientChallenge() {
		return CkNtlm_clientChallenge($this->_cPtr);
	}

	function put_ClientChallenge($newVal) {
		CkNtlm_put_ClientChallenge($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkNtlm_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkNtlm_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkNtlm_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DnsComputerName($str) {
		CkNtlm_get_DnsComputerName($this->_cPtr,$str);
	}

	function dnsComputerName() {
		return CkNtlm_dnsComputerName($this->_cPtr);
	}

	function put_DnsComputerName($newVal) {
		CkNtlm_put_DnsComputerName($this->_cPtr,$newVal);
	}

	function get_DnsDomainName($str) {
		CkNtlm_get_DnsDomainName($this->_cPtr,$str);
	}

	function dnsDomainName() {
		return CkNtlm_dnsDomainName($this->_cPtr);
	}

	function put_DnsDomainName($newVal) {
		CkNtlm_put_DnsDomainName($this->_cPtr,$newVal);
	}

	function get_Domain($str) {
		CkNtlm_get_Domain($this->_cPtr,$str);
	}

	function domain() {
		return CkNtlm_domain($this->_cPtr);
	}

	function put_Domain($newVal) {
		CkNtlm_put_Domain($this->_cPtr,$newVal);
	}

	function get_EncodingMode($str) {
		CkNtlm_get_EncodingMode($this->_cPtr,$str);
	}

	function encodingMode() {
		return CkNtlm_encodingMode($this->_cPtr);
	}

	function put_EncodingMode($newVal) {
		CkNtlm_put_EncodingMode($this->_cPtr,$newVal);
	}

	function get_Flags($str) {
		CkNtlm_get_Flags($this->_cPtr,$str);
	}

	function flags() {
		return CkNtlm_flags($this->_cPtr);
	}

	function put_Flags($newVal) {
		CkNtlm_put_Flags($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkNtlm_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkNtlm_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkNtlm_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkNtlm_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkNtlm_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkNtlm_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkNtlm_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkNtlm_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NetBiosComputerName($str) {
		CkNtlm_get_NetBiosComputerName($this->_cPtr,$str);
	}

	function netBiosComputerName() {
		return CkNtlm_netBiosComputerName($this->_cPtr);
	}

	function put_NetBiosComputerName($newVal) {
		CkNtlm_put_NetBiosComputerName($this->_cPtr,$newVal);
	}

	function get_NetBiosDomainName($str) {
		CkNtlm_get_NetBiosDomainName($this->_cPtr,$str);
	}

	function netBiosDomainName() {
		return CkNtlm_netBiosDomainName($this->_cPtr);
	}

	function put_NetBiosDomainName($newVal) {
		CkNtlm_put_NetBiosDomainName($this->_cPtr,$newVal);
	}

	function get_NtlmVersion() {
		return CkNtlm_get_NtlmVersion($this->_cPtr);
	}

	function put_NtlmVersion($newVal) {
		CkNtlm_put_NtlmVersion($this->_cPtr,$newVal);
	}

	function get_OemCodePage() {
		return CkNtlm_get_OemCodePage($this->_cPtr);
	}

	function put_OemCodePage($newVal) {
		CkNtlm_put_OemCodePage($this->_cPtr,$newVal);
	}

	function get_Password($str) {
		CkNtlm_get_Password($this->_cPtr,$str);
	}

	function password() {
		return CkNtlm_password($this->_cPtr);
	}

	function put_Password($newVal) {
		CkNtlm_put_Password($this->_cPtr,$newVal);
	}

	function get_ServerChallenge($str) {
		CkNtlm_get_ServerChallenge($this->_cPtr,$str);
	}

	function serverChallenge() {
		return CkNtlm_serverChallenge($this->_cPtr);
	}

	function put_ServerChallenge($newVal) {
		CkNtlm_put_ServerChallenge($this->_cPtr,$newVal);
	}

	function get_TargetName($str) {
		CkNtlm_get_TargetName($this->_cPtr,$str);
	}

	function targetName() {
		return CkNtlm_targetName($this->_cPtr);
	}

	function put_TargetName($newVal) {
		CkNtlm_put_TargetName($this->_cPtr,$newVal);
	}

	function get_UserName($str) {
		CkNtlm_get_UserName($this->_cPtr,$str);
	}

	function userName() {
		return CkNtlm_userName($this->_cPtr);
	}

	function put_UserName($newVal) {
		CkNtlm_put_UserName($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkNtlm_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkNtlm_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkNtlm_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkNtlm_version($this->_cPtr);
	}

	function get_Workstation($str) {
		CkNtlm_get_Workstation($this->_cPtr,$str);
	}

	function workstation() {
		return CkNtlm_workstation($this->_cPtr);
	}

	function put_Workstation($newVal) {
		CkNtlm_put_Workstation($this->_cPtr,$newVal);
	}

	function CompareType3($msg1,$msg2) {
		return CkNtlm_CompareType3($this->_cPtr,$msg1,$msg2);
	}

	function genType1() {
		return CkNtlm_genType1($this->_cPtr);
	}

	function genType2($type1Msg) {
		return CkNtlm_genType2($this->_cPtr,$type1Msg);
	}

	function genType3($type2Msg) {
		return CkNtlm_genType3($this->_cPtr,$type2Msg);
	}

	function LoadType3($type3Msg) {
		return CkNtlm_LoadType3($this->_cPtr,$type3Msg);
	}

	function parseType1($type1Msg) {
		return CkNtlm_parseType1($this->_cPtr,$type1Msg);
	}

	function parseType2($type2Msg) {
		return CkNtlm_parseType2($this->_cPtr,$type2Msg);
	}

	function parseType3($type3Msg) {
		return CkNtlm_parseType3($this->_cPtr,$type3Msg);
	}

	function SetFlag($flagLetter,$onOrOff) {
		return CkNtlm_SetFlag($this->_cPtr,$flagLetter,$onOrOff);
	}
}

class CkOAuth1 {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkOAuth1') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkOAuth1();
	}

	function get_Utf8() {
		return CkOAuth1_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkOAuth1_put_Utf8($this->_cPtr,$b);
	}

	function get_AuthorizationHeader($str) {
		CkOAuth1_get_AuthorizationHeader($this->_cPtr,$str);
	}

	function authorizationHeader() {
		return CkOAuth1_authorizationHeader($this->_cPtr);
	}

	function get_BaseString($str) {
		CkOAuth1_get_BaseString($this->_cPtr,$str);
	}

	function baseString() {
		return CkOAuth1_baseString($this->_cPtr);
	}

	function get_ConsumerKey($str) {
		CkOAuth1_get_ConsumerKey($this->_cPtr,$str);
	}

	function consumerKey() {
		return CkOAuth1_consumerKey($this->_cPtr);
	}

	function put_ConsumerKey($newVal) {
		CkOAuth1_put_ConsumerKey($this->_cPtr,$newVal);
	}

	function get_ConsumerSecret($str) {
		CkOAuth1_get_ConsumerSecret($this->_cPtr,$str);
	}

	function consumerSecret() {
		return CkOAuth1_consumerSecret($this->_cPtr);
	}

	function put_ConsumerSecret($newVal) {
		CkOAuth1_put_ConsumerSecret($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkOAuth1_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkOAuth1_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkOAuth1_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EncodedSignature($str) {
		CkOAuth1_get_EncodedSignature($this->_cPtr,$str);
	}

	function encodedSignature() {
		return CkOAuth1_encodedSignature($this->_cPtr);
	}

	function get_GeneratedUrl($str) {
		CkOAuth1_get_GeneratedUrl($this->_cPtr,$str);
	}

	function generatedUrl() {
		return CkOAuth1_generatedUrl($this->_cPtr);
	}

	function get_HmacKey($str) {
		CkOAuth1_get_HmacKey($this->_cPtr,$str);
	}

	function hmacKey() {
		return CkOAuth1_hmacKey($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkOAuth1_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkOAuth1_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkOAuth1_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkOAuth1_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkOAuth1_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkOAuth1_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkOAuth1_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkOAuth1_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Nonce($str) {
		CkOAuth1_get_Nonce($this->_cPtr,$str);
	}

	function nonce() {
		return CkOAuth1_nonce($this->_cPtr);
	}

	function put_Nonce($newVal) {
		CkOAuth1_put_Nonce($this->_cPtr,$newVal);
	}

	function get_OauthMethod($str) {
		CkOAuth1_get_OauthMethod($this->_cPtr,$str);
	}

	function oauthMethod() {
		return CkOAuth1_oauthMethod($this->_cPtr);
	}

	function put_OauthMethod($newVal) {
		CkOAuth1_put_OauthMethod($this->_cPtr,$newVal);
	}

	function get_OauthUrl($str) {
		CkOAuth1_get_OauthUrl($this->_cPtr,$str);
	}

	function oauthUrl() {
		return CkOAuth1_oauthUrl($this->_cPtr);
	}

	function put_OauthUrl($newVal) {
		CkOAuth1_put_OauthUrl($this->_cPtr,$newVal);
	}

	function get_OauthVersion($str) {
		CkOAuth1_get_OauthVersion($this->_cPtr,$str);
	}

	function oauthVersion() {
		return CkOAuth1_oauthVersion($this->_cPtr);
	}

	function put_OauthVersion($newVal) {
		CkOAuth1_put_OauthVersion($this->_cPtr,$newVal);
	}

	function get_QueryString($str) {
		CkOAuth1_get_QueryString($this->_cPtr,$str);
	}

	function queryString() {
		return CkOAuth1_queryString($this->_cPtr);
	}

	function get_Realm($str) {
		CkOAuth1_get_Realm($this->_cPtr,$str);
	}

	function realm() {
		return CkOAuth1_realm($this->_cPtr);
	}

	function put_Realm($newVal) {
		CkOAuth1_put_Realm($this->_cPtr,$newVal);
	}

	function get_Signature($str) {
		CkOAuth1_get_Signature($this->_cPtr,$str);
	}

	function signature() {
		return CkOAuth1_signature($this->_cPtr);
	}

	function get_SignatureMethod($str) {
		CkOAuth1_get_SignatureMethod($this->_cPtr,$str);
	}

	function signatureMethod() {
		return CkOAuth1_signatureMethod($this->_cPtr);
	}

	function put_SignatureMethod($newVal) {
		CkOAuth1_put_SignatureMethod($this->_cPtr,$newVal);
	}

	function get_Timestamp($str) {
		CkOAuth1_get_Timestamp($this->_cPtr,$str);
	}

	function timestamp() {
		return CkOAuth1_timestamp($this->_cPtr);
	}

	function put_Timestamp($newVal) {
		CkOAuth1_put_Timestamp($this->_cPtr,$newVal);
	}

	function get_Token($str) {
		CkOAuth1_get_Token($this->_cPtr,$str);
	}

	function token() {
		return CkOAuth1_token($this->_cPtr);
	}

	function put_Token($newVal) {
		CkOAuth1_put_Token($this->_cPtr,$newVal);
	}

	function get_TokenSecret($str) {
		CkOAuth1_get_TokenSecret($this->_cPtr,$str);
	}

	function tokenSecret() {
		return CkOAuth1_tokenSecret($this->_cPtr);
	}

	function put_TokenSecret($newVal) {
		CkOAuth1_put_TokenSecret($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkOAuth1_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkOAuth1_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkOAuth1_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkOAuth1_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkOAuth1_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkOAuth1_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkOAuth1_version($this->_cPtr);
	}

	function AddParam($name,$value) {
		return CkOAuth1_AddParam($this->_cPtr,$name,$value);
	}

	function Generate() {
		return CkOAuth1_Generate($this->_cPtr);
	}

	function GenNonce($numBytes) {
		return CkOAuth1_GenNonce($this->_cPtr,$numBytes);
	}

	function GenTimestamp() {
		return CkOAuth1_GenTimestamp($this->_cPtr);
	}

	function RemoveParam($name) {
		return CkOAuth1_RemoveParam($this->_cPtr,$name);
	}

	function SetRsaKey($privKey) {
		return CkOAuth1_SetRsaKey($this->_cPtr,$privKey);
	}
}

class CkOAuth2 {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkOAuth2') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkOAuth2();
	}

	function get_Utf8() {
		return CkOAuth2_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkOAuth2_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkOAuth2_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AccessToken($str) {
		CkOAuth2_get_AccessToken($this->_cPtr,$str);
	}

	function accessToken() {
		return CkOAuth2_accessToken($this->_cPtr);
	}

	function put_AccessToken($newVal) {
		CkOAuth2_put_AccessToken($this->_cPtr,$newVal);
	}

	function get_AccessTokenResponse($str) {
		CkOAuth2_get_AccessTokenResponse($this->_cPtr,$str);
	}

	function accessTokenResponse() {
		return CkOAuth2_accessTokenResponse($this->_cPtr);
	}

	function get_AppCallbackUrl($str) {
		CkOAuth2_get_AppCallbackUrl($this->_cPtr,$str);
	}

	function appCallbackUrl() {
		return CkOAuth2_appCallbackUrl($this->_cPtr);
	}

	function put_AppCallbackUrl($newVal) {
		CkOAuth2_put_AppCallbackUrl($this->_cPtr,$newVal);
	}

	function get_AuthFlowState() {
		return CkOAuth2_get_AuthFlowState($this->_cPtr);
	}

	function get_AuthorizationEndpoint($str) {
		CkOAuth2_get_AuthorizationEndpoint($this->_cPtr,$str);
	}

	function authorizationEndpoint() {
		return CkOAuth2_authorizationEndpoint($this->_cPtr);
	}

	function put_AuthorizationEndpoint($newVal) {
		CkOAuth2_put_AuthorizationEndpoint($this->_cPtr,$newVal);
	}

	function get_ClientId($str) {
		CkOAuth2_get_ClientId($this->_cPtr,$str);
	}

	function clientId() {
		return CkOAuth2_clientId($this->_cPtr);
	}

	function put_ClientId($newVal) {
		CkOAuth2_put_ClientId($this->_cPtr,$newVal);
	}

	function get_ClientSecret($str) {
		CkOAuth2_get_ClientSecret($this->_cPtr,$str);
	}

	function clientSecret() {
		return CkOAuth2_clientSecret($this->_cPtr);
	}

	function put_ClientSecret($newVal) {
		CkOAuth2_put_ClientSecret($this->_cPtr,$newVal);
	}

	function get_CodeChallenge() {
		return CkOAuth2_get_CodeChallenge($this->_cPtr);
	}

	function put_CodeChallenge($newVal) {
		CkOAuth2_put_CodeChallenge($this->_cPtr,$newVal);
	}

	function get_CodeChallengeMethod($str) {
		CkOAuth2_get_CodeChallengeMethod($this->_cPtr,$str);
	}

	function codeChallengeMethod() {
		return CkOAuth2_codeChallengeMethod($this->_cPtr);
	}

	function put_CodeChallengeMethod($newVal) {
		CkOAuth2_put_CodeChallengeMethod($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkOAuth2_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkOAuth2_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkOAuth2_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_FailureInfo($str) {
		CkOAuth2_get_FailureInfo($this->_cPtr,$str);
	}

	function failureInfo() {
		return CkOAuth2_failureInfo($this->_cPtr);
	}

	function get_IncludeNonce() {
		return CkOAuth2_get_IncludeNonce($this->_cPtr);
	}

	function put_IncludeNonce($newVal) {
		CkOAuth2_put_IncludeNonce($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkOAuth2_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkOAuth2_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkOAuth2_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkOAuth2_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkOAuth2_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkOAuth2_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkOAuth2_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkOAuth2_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_ListenPort() {
		return CkOAuth2_get_ListenPort($this->_cPtr);
	}

	function put_ListenPort($newVal) {
		CkOAuth2_put_ListenPort($this->_cPtr,$newVal);
	}

	function get_ListenPortRangeEnd() {
		return CkOAuth2_get_ListenPortRangeEnd($this->_cPtr);
	}

	function put_ListenPortRangeEnd($newVal) {
		CkOAuth2_put_ListenPortRangeEnd($this->_cPtr,$newVal);
	}

	function get_ListenPortSelected() {
		return CkOAuth2_get_ListenPortSelected($this->_cPtr);
	}

	function get_LocalHost($str) {
		CkOAuth2_get_LocalHost($this->_cPtr,$str);
	}

	function localHost() {
		return CkOAuth2_localHost($this->_cPtr);
	}

	function put_LocalHost($newVal) {
		CkOAuth2_put_LocalHost($this->_cPtr,$newVal);
	}

	function get_NonceLength() {
		return CkOAuth2_get_NonceLength($this->_cPtr);
	}

	function put_NonceLength($newVal) {
		CkOAuth2_put_NonceLength($this->_cPtr,$newVal);
	}

	function get_Oob() {
		return CkOAuth2_get_Oob($this->_cPtr);
	}

	function put_Oob($newVal) {
		CkOAuth2_put_Oob($this->_cPtr,$newVal);
	}

	function get_RedirectAllowHtml($str) {
		CkOAuth2_get_RedirectAllowHtml($this->_cPtr,$str);
	}

	function redirectAllowHtml() {
		return CkOAuth2_redirectAllowHtml($this->_cPtr);
	}

	function put_RedirectAllowHtml($newVal) {
		CkOAuth2_put_RedirectAllowHtml($this->_cPtr,$newVal);
	}

	function get_RedirectDenyHtml($str) {
		CkOAuth2_get_RedirectDenyHtml($this->_cPtr,$str);
	}

	function redirectDenyHtml() {
		return CkOAuth2_redirectDenyHtml($this->_cPtr);
	}

	function put_RedirectDenyHtml($newVal) {
		CkOAuth2_put_RedirectDenyHtml($this->_cPtr,$newVal);
	}

	function get_RedirectReqReceived($str) {
		CkOAuth2_get_RedirectReqReceived($this->_cPtr,$str);
	}

	function redirectReqReceived() {
		return CkOAuth2_redirectReqReceived($this->_cPtr);
	}

	function get_RefreshToken($str) {
		CkOAuth2_get_RefreshToken($this->_cPtr,$str);
	}

	function refreshToken() {
		return CkOAuth2_refreshToken($this->_cPtr);
	}

	function put_RefreshToken($newVal) {
		CkOAuth2_put_RefreshToken($this->_cPtr,$newVal);
	}

	function get_Resource($str) {
		CkOAuth2_get_Resource($this->_cPtr,$str);
	}

	function resource() {
		return CkOAuth2_resource($this->_cPtr);
	}

	function put_Resource($newVal) {
		CkOAuth2_put_Resource($this->_cPtr,$newVal);
	}

	function get_ResponseMode($str) {
		CkOAuth2_get_ResponseMode($this->_cPtr,$str);
	}

	function responseMode() {
		return CkOAuth2_responseMode($this->_cPtr);
	}

	function put_ResponseMode($newVal) {
		CkOAuth2_put_ResponseMode($this->_cPtr,$newVal);
	}

	function get_ResponseType($str) {
		CkOAuth2_get_ResponseType($this->_cPtr,$str);
	}

	function responseType() {
		return CkOAuth2_responseType($this->_cPtr);
	}

	function put_ResponseType($newVal) {
		CkOAuth2_put_ResponseType($this->_cPtr,$newVal);
	}

	function get_Scope($str) {
		CkOAuth2_get_Scope($this->_cPtr,$str);
	}

	function scope() {
		return CkOAuth2_scope($this->_cPtr);
	}

	function put_Scope($newVal) {
		CkOAuth2_put_Scope($this->_cPtr,$newVal);
	}

	function get_StateParam($str) {
		CkOAuth2_get_StateParam($this->_cPtr,$str);
	}

	function stateParam() {
		return CkOAuth2_stateParam($this->_cPtr);
	}

	function put_StateParam($newVal) {
		CkOAuth2_put_StateParam($this->_cPtr,$newVal);
	}

	function get_TokenEndpoint($str) {
		CkOAuth2_get_TokenEndpoint($this->_cPtr,$str);
	}

	function tokenEndpoint() {
		return CkOAuth2_tokenEndpoint($this->_cPtr);
	}

	function put_TokenEndpoint($newVal) {
		CkOAuth2_put_TokenEndpoint($this->_cPtr,$newVal);
	}

	function get_TokenType($str) {
		CkOAuth2_get_TokenType($this->_cPtr,$str);
	}

	function tokenType() {
		return CkOAuth2_tokenType($this->_cPtr);
	}

	function put_TokenType($newVal) {
		CkOAuth2_put_TokenType($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkOAuth2_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkOAuth2_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkOAuth2_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UseBasicAuth() {
		return CkOAuth2_get_UseBasicAuth($this->_cPtr);
	}

	function put_UseBasicAuth($newVal) {
		CkOAuth2_put_UseBasicAuth($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkOAuth2_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkOAuth2_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkOAuth2_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkOAuth2_version($this->_cPtr);
	}

	function AddAuthQueryParam($name,$value) {
		return CkOAuth2_AddAuthQueryParam($this->_cPtr,$name,$value);
	}

	function AddRefreshQueryParam($name,$value) {
		return CkOAuth2_AddRefreshQueryParam($this->_cPtr,$name,$value);
	}

	function AddTokenQueryParam($name,$value) {
		return CkOAuth2_AddTokenQueryParam($this->_cPtr,$name,$value);
	}

	function Cancel() {
		return CkOAuth2_Cancel($this->_cPtr);
	}

	function ExchangeCodeForToken($code) {
		return CkOAuth2_ExchangeCodeForToken($this->_cPtr,$code);
	}

	function ExchangeCodeForTokenAsync($code) {
		$r=CkOAuth2_ExchangeCodeForTokenAsync($this->_cPtr,$code);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetAccessTokenResponseSb($sb) {
		return CkOAuth2_GetAccessTokenResponseSb($this->_cPtr,$sb);
	}

	function getRedirectRequestParam($paramName) {
		return CkOAuth2_getRedirectRequestParam($this->_cPtr,$paramName);
	}

	function redirectRequestParam($paramName) {
		return CkOAuth2_redirectRequestParam($this->_cPtr,$paramName);
	}

	function LaunchBrowser($url) {
		return CkOAuth2_LaunchBrowser($this->_cPtr,$url);
	}

	function LoadTaskCaller($task) {
		return CkOAuth2_LoadTaskCaller($this->_cPtr,$task);
	}

	function RefreshAccessToken() {
		return CkOAuth2_RefreshAccessToken($this->_cPtr);
	}

	function RefreshAccessTokenAsync() {
		$r=CkOAuth2_RefreshAccessTokenAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetRefreshHeader($name,$value) {
		return CkOAuth2_SetRefreshHeader($this->_cPtr,$name,$value);
	}

	function SleepMs($millisec) {
		CkOAuth2_SleepMs($this->_cPtr,$millisec);
	}

	function startAuth() {
		return CkOAuth2_startAuth($this->_cPtr);
	}

	function UseConnection($sock) {
		return CkOAuth2_UseConnection($this->_cPtr,$sock);
	}
}

class CkPdf {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkPdf') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkPdf();
	}

	function get_Utf8() {
		return CkPdf_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkPdf_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkPdf_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_DebugLogFilePath($str) {
		CkPdf_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkPdf_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkPdf_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_HasCertificationSig() {
		return CkPdf_get_HasCertificationSig($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkPdf_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkPdf_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkPdf_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkPdf_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkPdf_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkPdf_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkPdf_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkPdf_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumEmbeddedFiles() {
		return CkPdf_get_NumEmbeddedFiles($this->_cPtr);
	}

	function get_NumPages() {
		return CkPdf_get_NumPages($this->_cPtr);
	}

	function get_NumSignatures() {
		return CkPdf_get_NumSignatures($this->_cPtr);
	}

	function get_OwnerPassword($str) {
		CkPdf_get_OwnerPassword($this->_cPtr,$str);
	}

	function ownerPassword() {
		return CkPdf_ownerPassword($this->_cPtr);
	}

	function put_OwnerPassword($newVal) {
		CkPdf_put_OwnerPassword($this->_cPtr,$newVal);
	}

	function get_SigAllocateSize() {
		return CkPdf_get_SigAllocateSize($this->_cPtr);
	}

	function put_SigAllocateSize($newVal) {
		CkPdf_put_SigAllocateSize($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkPdf_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkPdf_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkPdf_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UserPassword($str) {
		CkPdf_get_UserPassword($this->_cPtr,$str);
	}

	function userPassword() {
		return CkPdf_userPassword($this->_cPtr);
	}

	function put_UserPassword($newVal) {
		CkPdf_put_UserPassword($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkPdf_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkPdf_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkPdf_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkPdf_version($this->_cPtr);
	}

	function AddEmbeddedFiles($json,$outFilePath) {
		return CkPdf_AddEmbeddedFiles($this->_cPtr,$json,$outFilePath);
	}

	function AddEmbeddedFilesBd($json,$bd) {
		return CkPdf_AddEmbeddedFilesBd($this->_cPtr,$json,$bd);
	}

	function AddSigningCert($cert) {
		return CkPdf_AddSigningCert($this->_cPtr,$cert);
	}

	function AddVerificationInfo($jsonOptions,$outFilePath) {
		return CkPdf_AddVerificationInfo($this->_cPtr,$jsonOptions,$outFilePath);
	}

	function AddVerificationInfoAsync($jsonOptions,$outFilePath) {
		$r=CkPdf_AddVerificationInfoAsync($this->_cPtr,$jsonOptions,$outFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetDss($json) {
		return CkPdf_GetDss($this->_cPtr,$json);
	}

	function GetEmbeddedFileBd($index,$bd) {
		return CkPdf_GetEmbeddedFileBd($this->_cPtr,$index,$bd);
	}

	function GetEmbeddedFileInfo($index,$json) {
		return CkPdf_GetEmbeddedFileInfo($this->_cPtr,$index,$json);
	}

	function GetLastJsonData($json) {
		CkPdf_GetLastJsonData($this->_cPtr,$json);
	}

	function GetMetadata($sb) {
		return CkPdf_GetMetadata($this->_cPtr,$sb);
	}

	function GetSignatureContent($index,$bd) {
		return CkPdf_GetSignatureContent($this->_cPtr,$index,$bd);
	}

	function GetSignerCert($index,$cert) {
		return CkPdf_GetSignerCert($this->_cPtr,$index,$cert);
	}

	function GetUnsignedSigFields($json) {
		return CkPdf_GetUnsignedSigFields($this->_cPtr,$json);
	}

	function LastJsonData() {
		$r=CkPdf_LastJsonData($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LoadBd($pdfData) {
		return CkPdf_LoadBd($this->_cPtr,$pdfData);
	}

	function LoadFile($filePath) {
		return CkPdf_LoadFile($this->_cPtr,$filePath);
	}

	function SetHttpObj($http) {
		CkPdf_SetHttpObj($this->_cPtr,$http);
	}

	function SetSignatureJpeg($jpgData) {
		return CkPdf_SetSignatureJpeg($this->_cPtr,$jpgData);
	}

	function SetSigningCert($cert) {
		return CkPdf_SetSigningCert($this->_cPtr,$cert);
	}

	function SetSigningCert2($cert,$privateKey) {
		return CkPdf_SetSigningCert2($this->_cPtr,$cert,$privateKey);
	}

	function SignPdf($jsonOptions,$outFilePath) {
		return CkPdf_SignPdf($this->_cPtr,$jsonOptions,$outFilePath);
	}

	function SignPdfAsync($jsonOptions,$outFilePath) {
		$r=CkPdf_SignPdfAsync($this->_cPtr,$jsonOptions,$outFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SignPdfBd($jsonOptions,$bd) {
		return CkPdf_SignPdfBd($this->_cPtr,$jsonOptions,$bd);
	}

	function SignPdfBdAsync($jsonOptions,$bd) {
		$r=CkPdf_SignPdfBdAsync($this->_cPtr,$jsonOptions,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UpdateMetadata($sb,$outFilePath) {
		return CkPdf_UpdateMetadata($this->_cPtr,$sb,$outFilePath);
	}

	function UpdateMetadataBd($sb,$bd) {
		return CkPdf_UpdateMetadataBd($this->_cPtr,$sb,$bd);
	}

	function VerifySignature($index,$sigInfo) {
		return CkPdf_VerifySignature($this->_cPtr,$index,$sigInfo);
	}
}

class CkPem {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkPem') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkPem();
	}

	function get_Utf8() {
		return CkPem_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkPem_put_Utf8($this->_cPtr,$b);
	}

	function get_AppendMode() {
		return CkPem_get_AppendMode($this->_cPtr);
	}

	function put_AppendMode($newVal) {
		CkPem_put_AppendMode($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkPem_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkPem_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkPem_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkPem_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkPem_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkPem_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkPem_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkPem_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkPem_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkPem_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkPem_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkPem_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkPem_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumCerts() {
		return CkPem_get_NumCerts($this->_cPtr);
	}

	function get_NumCrls() {
		return CkPem_get_NumCrls($this->_cPtr);
	}

	function get_NumCsrs() {
		return CkPem_get_NumCsrs($this->_cPtr);
	}

	function get_NumPrivateKeys() {
		return CkPem_get_NumPrivateKeys($this->_cPtr);
	}

	function get_NumPublicKeys() {
		return CkPem_get_NumPublicKeys($this->_cPtr);
	}

	function get_PrivateKeyFormat($str) {
		CkPem_get_PrivateKeyFormat($this->_cPtr,$str);
	}

	function privateKeyFormat() {
		return CkPem_privateKeyFormat($this->_cPtr);
	}

	function put_PrivateKeyFormat($newVal) {
		CkPem_put_PrivateKeyFormat($this->_cPtr,$newVal);
	}

	function get_PublicKeyFormat($str) {
		CkPem_get_PublicKeyFormat($this->_cPtr,$str);
	}

	function publicKeyFormat() {
		return CkPem_publicKeyFormat($this->_cPtr);
	}

	function put_PublicKeyFormat($newVal) {
		CkPem_put_PublicKeyFormat($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkPem_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkPem_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkPem_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkPem_version($this->_cPtr);
	}

	function AddCert($cert,$includeChain) {
		return CkPem_AddCert($this->_cPtr,$cert,$includeChain);
	}

	function AddItem($itemType,$encoding,$itemData) {
		return CkPem_AddItem($this->_cPtr,$itemType,$encoding,$itemData);
	}

	function AddP7b($bd) {
		return CkPem_AddP7b($this->_cPtr,$bd);
	}

	function AddPrivateKey($privateKey) {
		return CkPem_AddPrivateKey($this->_cPtr,$privateKey);
	}

	function AddPrivateKey2($privKey,$certChain) {
		return CkPem_AddPrivateKey2($this->_cPtr,$privKey,$certChain);
	}

	function AddPublicKey($pubkey) {
		return CkPem_AddPublicKey($this->_cPtr,$pubkey);
	}

	function CertAt($index,$cert) {
		return CkPem_CertAt($this->_cPtr,$index,$cert);
	}

	function Clear() {
		return CkPem_Clear($this->_cPtr);
	}

	function GetCert($index) {
		$r=CkPem_GetCert($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function getEncodedItem($itemType,$itemSubType,$encoding,$index) {
		return CkPem_getEncodedItem($this->_cPtr,$itemType,$itemSubType,$encoding,$index);
	}

	function encodedItem($itemType,$itemSubType,$encoding,$index) {
		return CkPem_encodedItem($this->_cPtr,$itemType,$itemSubType,$encoding,$index);
	}

	function GetPrivateKey($index) {
		$r=CkPem_GetPrivateKey($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPrivateKey($r);
		}
		return $r;
	}

	function GetPublicKey($index) {
		$r=CkPem_GetPublicKey($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPublicKey($r);
		}
		return $r;
	}

	function LoadP7b($p7bData) {
		return CkPem_LoadP7b($this->_cPtr,$p7bData);
	}

	function LoadP7bFile($path) {
		return CkPem_LoadP7bFile($this->_cPtr,$path);
	}

	function LoadPem($pemContent,$password) {
		return CkPem_LoadPem($this->_cPtr,$pemContent,$password);
	}

	function LoadPemFile($path,$password) {
		return CkPem_LoadPemFile($this->_cPtr,$path,$password);
	}

	function LoadTaskCaller($task) {
		return CkPem_LoadTaskCaller($this->_cPtr,$task);
	}

	function PrivateKeyAt($index,$privKey) {
		return CkPem_PrivateKeyAt($this->_cPtr,$index,$privKey);
	}

	function PublicKeyAt($index,$pubKey) {
		return CkPem_PublicKeyAt($this->_cPtr,$index,$pubKey);
	}

	function RemoveCert($index) {
		return CkPem_RemoveCert($this->_cPtr,$index);
	}

	function RemovePrivateKey($index) {
		return CkPem_RemovePrivateKey($this->_cPtr,$index);
	}

	function ToJks($alias,$password) {
		$r=CkPem_ToJks($this->_cPtr,$alias,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJavaKeyStore($r);
		}
		return $r;
	}

	function ToJksObj($alias,$password,$jksObj) {
		return CkPem_ToJksObj($this->_cPtr,$alias,$password,$jksObj);
	}

	function toPem() {
		return CkPem_toPem($this->_cPtr);
	}

	function toPemEx($extendedAttrs,$noKeys,$noCerts,$noCaCerts,$encryptAlg,$password) {
		return CkPem_toPemEx($this->_cPtr,$extendedAttrs,$noKeys,$noCerts,$noCaCerts,$encryptAlg,$password);
	}

	function ToPfx() {
		$r=CkPem_ToPfx($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPfx($r);
		}
		return $r;
	}

	function ToPfxObj($pfxObj) {
		return CkPem_ToPfxObj($this->_cPtr,$pfxObj);
	}
}

class CkPfx {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkPfx') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkPfx();
	}

	function get_Utf8() {
		return CkPfx_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkPfx_put_Utf8($this->_cPtr,$b);
	}

	function get_AlgorithmId($str) {
		CkPfx_get_AlgorithmId($this->_cPtr,$str);
	}

	function algorithmId() {
		return CkPfx_algorithmId($this->_cPtr);
	}

	function put_AlgorithmId($newVal) {
		CkPfx_put_AlgorithmId($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkPfx_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkPfx_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkPfx_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkPfx_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkPfx_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkPfx_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkPfx_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkPfx_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkPfx_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkPfx_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkPfx_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumCerts() {
		return CkPfx_get_NumCerts($this->_cPtr);
	}

	function get_NumPrivateKeys() {
		return CkPfx_get_NumPrivateKeys($this->_cPtr);
	}

	function get_Pbes2CryptAlg($str) {
		CkPfx_get_Pbes2CryptAlg($this->_cPtr,$str);
	}

	function pbes2CryptAlg() {
		return CkPfx_pbes2CryptAlg($this->_cPtr);
	}

	function put_Pbes2CryptAlg($newVal) {
		CkPfx_put_Pbes2CryptAlg($this->_cPtr,$newVal);
	}

	function get_Pbes2HmacAlg($str) {
		CkPfx_get_Pbes2HmacAlg($this->_cPtr,$str);
	}

	function pbes2HmacAlg() {
		return CkPfx_pbes2HmacAlg($this->_cPtr);
	}

	function put_Pbes2HmacAlg($newVal) {
		CkPfx_put_Pbes2HmacAlg($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkPfx_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkPfx_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkPfx_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkPfx_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkPfx_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkPfx_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkPfx_version($this->_cPtr);
	}

	function AddCert($cert,$includeChain) {
		return CkPfx_AddCert($this->_cPtr,$cert,$includeChain);
	}

	function AddPrivateKey($privKey,$certChain) {
		return CkPfx_AddPrivateKey($this->_cPtr,$privKey,$certChain);
	}

	function CertAt($index,$cert) {
		return CkPfx_CertAt($this->_cPtr,$index,$cert);
	}

	function CertByLocalKeyId($localKeyId,$encoding,$cert) {
		return CkPfx_CertByLocalKeyId($this->_cPtr,$localKeyId,$encoding,$cert);
	}

	function FindCertByLocalKeyId($localKeyId,$encoding) {
		$r=CkPfx_FindCertByLocalKeyId($this->_cPtr,$localKeyId,$encoding);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetCert($index) {
		$r=CkPfx_GetCert($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetLastJsonData($json) {
		CkPfx_GetLastJsonData($this->_cPtr,$json);
	}

	function GetPrivateKey($index) {
		$r=CkPfx_GetPrivateKey($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPrivateKey($r);
		}
		return $r;
	}

	function getSafeBagAttr($forPrivateKey,$index,$attrName) {
		return CkPfx_getSafeBagAttr($this->_cPtr,$forPrivateKey,$index,$attrName);
	}

	function safeBagAttr($forPrivateKey,$index,$attrName) {
		return CkPfx_safeBagAttr($this->_cPtr,$forPrivateKey,$index,$attrName);
	}

	function ImportToKeychain($opts) {
		return CkPfx_ImportToKeychain($this->_cPtr,$opts);
	}

	function ImportToWindows($exportable,$userProtected,$machineKeyset,$allowOverwriteKey,$allowExport,$leafStore,$intermediateStore,$rootStore,$extraOptions) {
		return CkPfx_ImportToWindows($this->_cPtr,$exportable,$userProtected,$machineKeyset,$allowOverwriteKey,$allowExport,$leafStore,$intermediateStore,$rootStore,$extraOptions);
	}

	function LastJsonData() {
		$r=CkPfx_LastJsonData($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LoadPem($pemStr,$password) {
		return CkPfx_LoadPem($this->_cPtr,$pemStr,$password);
	}

	function LoadPfxBd($bd,$password) {
		return CkPfx_LoadPfxBd($this->_cPtr,$bd,$password);
	}

	function LoadPfxBytes($pfxData,$password) {
		return CkPfx_LoadPfxBytes($this->_cPtr,$pfxData,$password);
	}

	function LoadPfxEncoded($encodedData,$encoding,$password) {
		return CkPfx_LoadPfxEncoded($this->_cPtr,$encodedData,$encoding,$password);
	}

	function LoadPfxFile($path,$password) {
		return CkPfx_LoadPfxFile($this->_cPtr,$path,$password);
	}

	function PrivateKeyAt($index,$privKey) {
		return CkPfx_PrivateKeyAt($this->_cPtr,$index,$privKey);
	}

	function SetSafeBagAttr($forPrivateKey,$index,$name,$value,$encoding) {
		return CkPfx_SetSafeBagAttr($this->_cPtr,$forPrivateKey,$index,$name,$value,$encoding);
	}

	function ToBd($password,$bd) {
		return CkPfx_ToBd($this->_cPtr,$password,$bd);
	}

	function ToBinary($password,$outBytes) {
		return CkPfx_ToBinary($this->_cPtr,$password,$outBytes);
	}

	function toEncodedString($password,$encoding) {
		return CkPfx_toEncodedString($this->_cPtr,$password,$encoding);
	}

	function ToFile($password,$path) {
		return CkPfx_ToFile($this->_cPtr,$password,$path);
	}

	function ToJavaKeyStore($alias,$password) {
		$r=CkPfx_ToJavaKeyStore($this->_cPtr,$alias,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJavaKeyStore($r);
		}
		return $r;
	}

	function ToJksObj($alias,$password,$jksObj) {
		return CkPfx_ToJksObj($this->_cPtr,$alias,$password,$jksObj);
	}

	function toPem() {
		return CkPfx_toPem($this->_cPtr);
	}

	function toPemEx($extendedAttrs,$noKeys,$noCerts,$noCaCerts,$encryptAlg,$password) {
		return CkPfx_toPemEx($this->_cPtr,$extendedAttrs,$noKeys,$noCerts,$noCaCerts,$encryptAlg,$password);
	}

	function UseCertVault($vault) {
		return CkPfx_UseCertVault($this->_cPtr,$vault);
	}
}

class CkPkcs11 {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkPkcs11') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkPkcs11();
	}

	function get_Utf8() {
		return CkPkcs11_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkPkcs11_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkPkcs11_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkPkcs11_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkPkcs11_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkPkcs11_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkPkcs11_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkPkcs11_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkPkcs11_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkPkcs11_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkPkcs11_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkPkcs11_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkPkcs11_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumCerts() {
		return CkPkcs11_get_NumCerts($this->_cPtr);
	}

	function get_SharedLibPath($str) {
		CkPkcs11_get_SharedLibPath($this->_cPtr,$str);
	}

	function sharedLibPath() {
		return CkPkcs11_sharedLibPath($this->_cPtr);
	}

	function put_SharedLibPath($newVal) {
		CkPkcs11_put_SharedLibPath($this->_cPtr,$newVal);
	}

	function get_SigContextPin($str) {
		CkPkcs11_get_SigContextPin($this->_cPtr,$str);
	}

	function sigContextPin() {
		return CkPkcs11_sigContextPin($this->_cPtr);
	}

	function put_SigContextPin($newVal) {
		CkPkcs11_put_SigContextPin($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkPkcs11_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkPkcs11_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkPkcs11_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkPkcs11_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkPkcs11_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkPkcs11_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkPkcs11_version($this->_cPtr);
	}

	function CloseSession() {
		return CkPkcs11_CloseSession($this->_cPtr);
	}

	function CreatePkcs11Object($attrs) {
		return CkPkcs11_CreatePkcs11Object($this->_cPtr,$attrs);
	}

	function DestroyObject($hObject) {
		return CkPkcs11_DestroyObject($this->_cPtr,$hObject);
	}

	function Discover($onlyTokensPresent,$json) {
		return CkPkcs11_Discover($this->_cPtr,$onlyTokensPresent,$json);
	}

	function ExportPublicKey($keyHandle,$pubKey) {
		return CkPkcs11_ExportPublicKey($this->_cPtr,$keyHandle,$pubKey);
	}

	function FindAllCerts() {
		return CkPkcs11_FindAllCerts($this->_cPtr);
	}

	function FindAllKeys($keyClass,$json) {
		return CkPkcs11_FindAllKeys($this->_cPtr,$keyClass,$json);
	}

	function FindCert($certPart,$partValue,$cert) {
		return CkPkcs11_FindCert($this->_cPtr,$certPart,$partValue,$cert);
	}

	function FindObject($jsonTemplate) {
		return CkPkcs11_FindObject($this->_cPtr,$jsonTemplate);
	}

	function GenEcKey($publicAttrs,$privateAttrs,$jsonOut,$pubKey) {
		return CkPkcs11_GenEcKey($this->_cPtr,$publicAttrs,$privateAttrs,$jsonOut,$pubKey);
	}

	function GenRsaKey($publicAttrs,$privateAttrs,$jsonOut,$pubKey) {
		return CkPkcs11_GenRsaKey($this->_cPtr,$publicAttrs,$privateAttrs,$jsonOut,$pubKey);
	}

	function GenSecretKey($keyType,$jsonTemplate) {
		return CkPkcs11_GenSecretKey($this->_cPtr,$keyType,$jsonTemplate);
	}

	function GetCert($index,$cert) {
		return CkPkcs11_GetCert($this->_cPtr,$index,$cert);
	}

	function ImportPrivateKey($privKey,$jsonTemplate) {
		return CkPkcs11_ImportPrivateKey($this->_cPtr,$privKey,$jsonTemplate);
	}

	function ImportSshKey($sshKey,$jsonTemplate) {
		return CkPkcs11_ImportSshKey($this->_cPtr,$sshKey,$jsonTemplate);
	}

	function Initialize() {
		return CkPkcs11_Initialize($this->_cPtr);
	}

	function InitPin($pin) {
		return CkPkcs11_InitPin($this->_cPtr,$pin);
	}

	function InitToken($slotId,$pin,$tokenLabel) {
		return CkPkcs11_InitToken($this->_cPtr,$slotId,$pin,$tokenLabel);
	}

	function Login($userType,$pin) {
		return CkPkcs11_Login($this->_cPtr,$userType,$pin);
	}

	function Logout() {
		return CkPkcs11_Logout($this->_cPtr);
	}

	function OpenSession($slotId,$readWrite) {
		return CkPkcs11_OpenSession($this->_cPtr,$slotId,$readWrite);
	}

	function QuickSession($userType,$pin) {
		return CkPkcs11_QuickSession($this->_cPtr,$userType,$pin);
	}

	function SetPin($oldPin,$newPin) {
		return CkPkcs11_SetPin($this->_cPtr,$oldPin,$newPin);
	}
}

class CkPrivateKey {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkPrivateKey') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkPrivateKey();
	}

	function get_Utf8() {
		return CkPrivateKey_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkPrivateKey_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkPrivateKey_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_BitLength() {
		return CkPrivateKey_get_BitLength($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkPrivateKey_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkPrivateKey_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkPrivateKey_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_KeyType($str) {
		CkPrivateKey_get_KeyType($this->_cPtr,$str);
	}

	function keyType() {
		return CkPrivateKey_keyType($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkPrivateKey_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkPrivateKey_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkPrivateKey_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkPrivateKey_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkPrivateKey_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkPrivateKey_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkPrivateKey_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkPrivateKey_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Pkcs8EncryptAlg($str) {
		CkPrivateKey_get_Pkcs8EncryptAlg($this->_cPtr,$str);
	}

	function pkcs8EncryptAlg() {
		return CkPrivateKey_pkcs8EncryptAlg($this->_cPtr);
	}

	function put_Pkcs8EncryptAlg($newVal) {
		CkPrivateKey_put_Pkcs8EncryptAlg($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkPrivateKey_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkPrivateKey_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkPrivateKey_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkPrivateKey_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkPrivateKey_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkPrivateKey_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkPrivateKey_version($this->_cPtr);
	}

	function getJwk() {
		return CkPrivateKey_getJwk($this->_cPtr);
	}

	function jwk() {
		return CkPrivateKey_jwk($this->_cPtr);
	}

	function getJwkThumbprint($hashAlg) {
		return CkPrivateKey_getJwkThumbprint($this->_cPtr,$hashAlg);
	}

	function jwkThumbprint($hashAlg) {
		return CkPrivateKey_jwkThumbprint($this->_cPtr,$hashAlg);
	}

	function GetPkcs1($outBytes) {
		return CkPrivateKey_GetPkcs1($this->_cPtr,$outBytes);
	}

	function getPkcs1ENC($encoding) {
		return CkPrivateKey_getPkcs1ENC($this->_cPtr,$encoding);
	}

	function pkcs1ENC($encoding) {
		return CkPrivateKey_pkcs1ENC($this->_cPtr,$encoding);
	}

	function getPkcs1Pem() {
		return CkPrivateKey_getPkcs1Pem($this->_cPtr);
	}

	function pkcs1Pem() {
		return CkPrivateKey_pkcs1Pem($this->_cPtr);
	}

	function GetPkcs8($outData) {
		return CkPrivateKey_GetPkcs8($this->_cPtr,$outData);
	}

	function getPkcs8ENC($encoding) {
		return CkPrivateKey_getPkcs8ENC($this->_cPtr,$encoding);
	}

	function pkcs8ENC($encoding) {
		return CkPrivateKey_pkcs8ENC($this->_cPtr,$encoding);
	}

	function GetPkcs8Encrypted($password,$outBytes) {
		return CkPrivateKey_GetPkcs8Encrypted($this->_cPtr,$password,$outBytes);
	}

	function getPkcs8EncryptedENC($encoding,$password) {
		return CkPrivateKey_getPkcs8EncryptedENC($this->_cPtr,$encoding,$password);
	}

	function pkcs8EncryptedENC($encoding,$password) {
		return CkPrivateKey_pkcs8EncryptedENC($this->_cPtr,$encoding,$password);
	}

	function getPkcs8EncryptedPem($password) {
		return CkPrivateKey_getPkcs8EncryptedPem($this->_cPtr,$password);
	}

	function pkcs8EncryptedPem($password) {
		return CkPrivateKey_pkcs8EncryptedPem($this->_cPtr,$password);
	}

	function getPkcs8Pem() {
		return CkPrivateKey_getPkcs8Pem($this->_cPtr);
	}

	function pkcs8Pem() {
		return CkPrivateKey_pkcs8Pem($this->_cPtr);
	}

	function GetPkcsBd($pkcs1,$password,$bd) {
		return CkPrivateKey_GetPkcsBd($this->_cPtr,$pkcs1,$password,$bd);
	}

	function GetPublicKey() {
		$r=CkPrivateKey_GetPublicKey($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPublicKey($r);
		}
		return $r;
	}

	function getRawHex($pubKey) {
		return CkPrivateKey_getRawHex($this->_cPtr,$pubKey);
	}

	function rawHex($pubKey) {
		return CkPrivateKey_rawHex($this->_cPtr,$pubKey);
	}

	function getXml() {
		return CkPrivateKey_getXml($this->_cPtr);
	}

	function xml() {
		return CkPrivateKey_xml($this->_cPtr);
	}

	function LoadAnyFormat($privKeyData,$password) {
		return CkPrivateKey_LoadAnyFormat($this->_cPtr,$privKeyData,$password);
	}

	function LoadAnyFormatFile($path,$password) {
		return CkPrivateKey_LoadAnyFormatFile($this->_cPtr,$path,$password);
	}

	function LoadEd25519($privKey,$pubKey) {
		return CkPrivateKey_LoadEd25519($this->_cPtr,$privKey,$pubKey);
	}

	function LoadEncryptedPem($pemStr,$password) {
		return CkPrivateKey_LoadEncryptedPem($this->_cPtr,$pemStr,$password);
	}

	function LoadEncryptedPemFile($path,$password) {
		return CkPrivateKey_LoadEncryptedPemFile($this->_cPtr,$path,$password);
	}

	function LoadJwk($jsonStr) {
		return CkPrivateKey_LoadJwk($this->_cPtr,$jsonStr);
	}

	function LoadPem($str) {
		return CkPrivateKey_LoadPem($this->_cPtr,$str);
	}

	function LoadPemFile($path) {
		return CkPrivateKey_LoadPemFile($this->_cPtr,$path);
	}

	function LoadPkcs1($data) {
		return CkPrivateKey_LoadPkcs1($this->_cPtr,$data);
	}

	function LoadPkcs1File($path) {
		return CkPrivateKey_LoadPkcs1File($this->_cPtr,$path);
	}

	function LoadPkcs8($data) {
		return CkPrivateKey_LoadPkcs8($this->_cPtr,$data);
	}

	function LoadPkcs8Encrypted($data,$password) {
		return CkPrivateKey_LoadPkcs8Encrypted($this->_cPtr,$data,$password);
	}

	function LoadPkcs8EncryptedFile($path,$password) {
		return CkPrivateKey_LoadPkcs8EncryptedFile($this->_cPtr,$path,$password);
	}

	function LoadPkcs8File($path) {
		return CkPrivateKey_LoadPkcs8File($this->_cPtr,$path);
	}

	function LoadPvk($data,$password) {
		return CkPrivateKey_LoadPvk($this->_cPtr,$data,$password);
	}

	function LoadPvkFile($path,$password) {
		return CkPrivateKey_LoadPvkFile($this->_cPtr,$path,$password);
	}

	function LoadXml($xml) {
		return CkPrivateKey_LoadXml($this->_cPtr,$xml);
	}

	function LoadXmlFile($path) {
		return CkPrivateKey_LoadXmlFile($this->_cPtr,$path);
	}

	function SavePemFile($path) {
		return CkPrivateKey_SavePemFile($this->_cPtr,$path);
	}

	function SavePkcs1File($path) {
		return CkPrivateKey_SavePkcs1File($this->_cPtr,$path);
	}

	function SavePkcs8EncryptedFile($password,$path) {
		return CkPrivateKey_SavePkcs8EncryptedFile($this->_cPtr,$password,$path);
	}

	function SavePkcs8EncryptedPemFile($password,$path) {
		return CkPrivateKey_SavePkcs8EncryptedPemFile($this->_cPtr,$password,$path);
	}

	function SavePkcs8File($path) {
		return CkPrivateKey_SavePkcs8File($this->_cPtr,$path);
	}

	function SavePkcs8PemFile($path) {
		return CkPrivateKey_SavePkcs8PemFile($this->_cPtr,$path);
	}

	function SaveXmlFile($path) {
		return CkPrivateKey_SaveXmlFile($this->_cPtr,$path);
	}

	function ToPublicKey($pubKey) {
		return CkPrivateKey_ToPublicKey($this->_cPtr,$pubKey);
	}

	function UploadToCloud($jsonIn,$jsonOut) {
		return CkPrivateKey_UploadToCloud($this->_cPtr,$jsonIn,$jsonOut);
	}

	function UploadToCloudAsync($jsonIn,$jsonOut) {
		$r=CkPrivateKey_UploadToCloudAsync($this->_cPtr,$jsonIn,$jsonOut);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkPrng {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkPrng') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkPrng();
	}

	function get_Utf8() {
		return CkPrng_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkPrng_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkPrng_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkPrng_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkPrng_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkPrng_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkPrng_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkPrng_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkPrng_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkPrng_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkPrng_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkPrng_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkPrng_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_PrngName($str) {
		CkPrng_get_PrngName($this->_cPtr,$str);
	}

	function prngName() {
		return CkPrng_prngName($this->_cPtr);
	}

	function put_PrngName($newVal) {
		CkPrng_put_PrngName($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkPrng_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkPrng_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkPrng_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkPrng_version($this->_cPtr);
	}

	function AddEntropy($entropy,$encoding) {
		return CkPrng_AddEntropy($this->_cPtr,$entropy,$encoding);
	}

	function AddEntropyBytes($entropy) {
		return CkPrng_AddEntropyBytes($this->_cPtr,$entropy);
	}

	function exportEntropy() {
		return CkPrng_exportEntropy($this->_cPtr);
	}

	function firebasePushId() {
		return CkPrng_firebasePushId($this->_cPtr);
	}

	function genRandom($numBytes,$encoding) {
		return CkPrng_genRandom($this->_cPtr,$numBytes,$encoding);
	}

	function GenRandomBd($numBytes,$bd) {
		return CkPrng_GenRandomBd($this->_cPtr,$numBytes,$bd);
	}

	function GenRandomBytes($numBytes,$outBytes) {
		return CkPrng_GenRandomBytes($this->_cPtr,$numBytes,$outBytes);
	}

	function getEntropy($numBytes,$encoding) {
		return CkPrng_getEntropy($this->_cPtr,$numBytes,$encoding);
	}

	function entropy($numBytes,$encoding) {
		return CkPrng_entropy($this->_cPtr,$numBytes,$encoding);
	}

	function GetEntropyBytes($numBytes,$outBytes) {
		return CkPrng_GetEntropyBytes($this->_cPtr,$numBytes,$outBytes);
	}

	function ImportEntropy($entropy) {
		return CkPrng_ImportEntropy($this->_cPtr,$entropy);
	}

	function RandomInt($low,$high) {
		return CkPrng_RandomInt($this->_cPtr,$low,$high);
	}

	function randomPassword($length,$mustIncludeDigit,$upperAndLowercase,$mustHaveOneOf,$excludeChars) {
		return CkPrng_randomPassword($this->_cPtr,$length,$mustIncludeDigit,$upperAndLowercase,$mustHaveOneOf,$excludeChars);
	}

	function randomString($length,$bDigits,$bLower,$bUpper) {
		return CkPrng_randomString($this->_cPtr,$length,$bDigits,$bLower,$bUpper);
	}
}

class CkPublicKey {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkPublicKey') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkPublicKey();
	}

	function get_Utf8() {
		return CkPublicKey_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkPublicKey_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkPublicKey_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkPublicKey_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkPublicKey_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Empty() {
		return CkPublicKey_get_Empty($this->_cPtr);
	}

	function get_KeySize() {
		return CkPublicKey_get_KeySize($this->_cPtr);
	}

	function get_KeyType($str) {
		CkPublicKey_get_KeyType($this->_cPtr,$str);
	}

	function keyType() {
		return CkPublicKey_keyType($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkPublicKey_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkPublicKey_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkPublicKey_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkPublicKey_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkPublicKey_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkPublicKey_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkPublicKey_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkPublicKey_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkPublicKey_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkPublicKey_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkPublicKey_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkPublicKey_version($this->_cPtr);
	}

	function GetDer($preferPkcs1,$outBytes) {
		return CkPublicKey_GetDer($this->_cPtr,$preferPkcs1,$outBytes);
	}

	function GetDerBd($preferPkcs1,$bd) {
		return CkPublicKey_GetDerBd($this->_cPtr,$preferPkcs1,$bd);
	}

	function getEncoded($preferPkcs1,$encoding) {
		return CkPublicKey_getEncoded($this->_cPtr,$preferPkcs1,$encoding);
	}

	function encoded($preferPkcs1,$encoding) {
		return CkPublicKey_encoded($this->_cPtr,$preferPkcs1,$encoding);
	}

	function getJwk() {
		return CkPublicKey_getJwk($this->_cPtr);
	}

	function jwk() {
		return CkPublicKey_jwk($this->_cPtr);
	}

	function getJwkThumbprint($hashAlg) {
		return CkPublicKey_getJwkThumbprint($this->_cPtr,$hashAlg);
	}

	function jwkThumbprint($hashAlg) {
		return CkPublicKey_jwkThumbprint($this->_cPtr,$hashAlg);
	}

	function getPem($preferPkcs1) {
		return CkPublicKey_getPem($this->_cPtr,$preferPkcs1);
	}

	function pem($preferPkcs1) {
		return CkPublicKey_pem($this->_cPtr,$preferPkcs1);
	}

	function getXml() {
		return CkPublicKey_getXml($this->_cPtr);
	}

	function xml() {
		return CkPublicKey_xml($this->_cPtr);
	}

	function LoadBase64($keyStr) {
		return CkPublicKey_LoadBase64($this->_cPtr,$keyStr);
	}

	function LoadBd($bd) {
		return CkPublicKey_LoadBd($this->_cPtr,$bd);
	}

	function LoadEcdsa($curveName,$Qx,$Qy) {
		return CkPublicKey_LoadEcdsa($this->_cPtr,$curveName,$Qx,$Qy);
	}

	function LoadEd25519($pubKey) {
		return CkPublicKey_LoadEd25519($this->_cPtr,$pubKey);
	}

	function LoadFromBinary($keyBytes) {
		return CkPublicKey_LoadFromBinary($this->_cPtr,$keyBytes);
	}

	function LoadFromFile($path) {
		return CkPublicKey_LoadFromFile($this->_cPtr,$path);
	}

	function LoadFromString($keyString) {
		return CkPublicKey_LoadFromString($this->_cPtr,$keyString);
	}

	function SaveDerFile($preferPkcs1,$path) {
		return CkPublicKey_SaveDerFile($this->_cPtr,$preferPkcs1,$path);
	}

	function SavePemFile($preferPkcs1,$path) {
		return CkPublicKey_SavePemFile($this->_cPtr,$preferPkcs1,$path);
	}

	function SaveXmlFile($path) {
		return CkPublicKey_SaveXmlFile($this->_cPtr,$path);
	}
}

class CkRest {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkRest') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkRest();
	}

	function get_Utf8() {
		return CkRest_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkRest_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkRest_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AllowHeaderFolding() {
		return CkRest_get_AllowHeaderFolding($this->_cPtr);
	}

	function put_AllowHeaderFolding($newVal) {
		CkRest_put_AllowHeaderFolding($this->_cPtr,$newVal);
	}

	function get_AllowHeaderQB() {
		return CkRest_get_AllowHeaderQB($this->_cPtr);
	}

	function put_AllowHeaderQB($newVal) {
		CkRest_put_AllowHeaderQB($this->_cPtr,$newVal);
	}

	function get_Authorization($str) {
		CkRest_get_Authorization($this->_cPtr,$str);
	}

	function authorization() {
		return CkRest_authorization($this->_cPtr);
	}

	function put_Authorization($newVal) {
		CkRest_put_Authorization($this->_cPtr,$newVal);
	}

	function get_ConnectFailReason() {
		return CkRest_get_ConnectFailReason($this->_cPtr);
	}

	function get_ConnectTimeoutMs() {
		return CkRest_get_ConnectTimeoutMs($this->_cPtr);
	}

	function put_ConnectTimeoutMs($newVal) {
		CkRest_put_ConnectTimeoutMs($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkRest_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkRest_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkRest_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DebugMode() {
		return CkRest_get_DebugMode($this->_cPtr);
	}

	function put_DebugMode($newVal) {
		CkRest_put_DebugMode($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkRest_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkRest_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_Host($str) {
		CkRest_get_Host($this->_cPtr,$str);
	}

	function host() {
		return CkRest_host($this->_cPtr);
	}

	function put_Host($newVal) {
		CkRest_put_Host($this->_cPtr,$newVal);
	}

	function get_IdleTimeoutMs() {
		return CkRest_get_IdleTimeoutMs($this->_cPtr);
	}

	function put_IdleTimeoutMs($newVal) {
		CkRest_put_IdleTimeoutMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkRest_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkRest_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkRest_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkRest_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkRest_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkRest_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkRest_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkRest_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LastRedirectUrl($str) {
		CkRest_get_LastRedirectUrl($this->_cPtr,$str);
	}

	function lastRedirectUrl() {
		return CkRest_lastRedirectUrl($this->_cPtr);
	}

	function get_LastRequestHeader($str) {
		CkRest_get_LastRequestHeader($this->_cPtr,$str);
	}

	function lastRequestHeader() {
		return CkRest_lastRequestHeader($this->_cPtr);
	}

	function get_LastRequestStartLine($str) {
		CkRest_get_LastRequestStartLine($this->_cPtr,$str);
	}

	function lastRequestStartLine() {
		return CkRest_lastRequestStartLine($this->_cPtr);
	}

	function get_NumResponseHeaders() {
		return CkRest_get_NumResponseHeaders($this->_cPtr);
	}

	function get_PartSelector($str) {
		CkRest_get_PartSelector($this->_cPtr,$str);
	}

	function partSelector() {
		return CkRest_partSelector($this->_cPtr);
	}

	function put_PartSelector($newVal) {
		CkRest_put_PartSelector($this->_cPtr,$newVal);
	}

	function get_PercentDoneOnSend() {
		return CkRest_get_PercentDoneOnSend($this->_cPtr);
	}

	function put_PercentDoneOnSend($newVal) {
		CkRest_put_PercentDoneOnSend($this->_cPtr,$newVal);
	}

	function get_ResponseHeader($str) {
		CkRest_get_ResponseHeader($this->_cPtr,$str);
	}

	function responseHeader() {
		return CkRest_responseHeader($this->_cPtr);
	}

	function get_ResponseStatusCode() {
		return CkRest_get_ResponseStatusCode($this->_cPtr);
	}

	function get_ResponseStatusText($str) {
		CkRest_get_ResponseStatusText($this->_cPtr,$str);
	}

	function responseStatusText() {
		return CkRest_responseStatusText($this->_cPtr);
	}

	function get_StreamNonChunked() {
		return CkRest_get_StreamNonChunked($this->_cPtr);
	}

	function put_StreamNonChunked($newVal) {
		CkRest_put_StreamNonChunked($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkRest_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkRest_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkRest_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkRest_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkRest_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkRest_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkRest_version($this->_cPtr);
	}

	function AddHeader($name,$value) {
		return CkRest_AddHeader($this->_cPtr,$name,$value);
	}

	function AddMwsSignature($httpVerb,$uriPath,$domain,$mwsSecretKey) {
		return CkRest_AddMwsSignature($this->_cPtr,$httpVerb,$uriPath,$domain,$mwsSecretKey);
	}

	function AddPathParam($name,$value) {
		return CkRest_AddPathParam($this->_cPtr,$name,$value);
	}

	function AddQueryParam($name,$value) {
		return CkRest_AddQueryParam($this->_cPtr,$name,$value);
	}

	function AddQueryParams($queryString) {
		return CkRest_AddQueryParams($this->_cPtr,$queryString);
	}

	function AddQueryParamSb($name,$value) {
		return CkRest_AddQueryParamSb($this->_cPtr,$name,$value);
	}

	function ClearAllHeaders() {
		return CkRest_ClearAllHeaders($this->_cPtr);
	}

	function ClearAllParts() {
		return CkRest_ClearAllParts($this->_cPtr);
	}

	function ClearAllPathParams() {
		return CkRest_ClearAllPathParams($this->_cPtr);
	}

	function ClearAllQueryParams() {
		return CkRest_ClearAllQueryParams($this->_cPtr);
	}

	function ClearAuth() {
		return CkRest_ClearAuth($this->_cPtr);
	}

	function ClearResponseBodyStream() {
		CkRest_ClearResponseBodyStream($this->_cPtr);
	}

	function Connect($hostname,$port,$tls,$autoReconnect) {
		return CkRest_Connect($this->_cPtr,$hostname,$port,$tls,$autoReconnect);
	}

	function ConnectAsync($hostname,$port,$tls,$autoReconnect) {
		$r=CkRest_ConnectAsync($this->_cPtr,$hostname,$port,$tls,$autoReconnect);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Disconnect($maxWaitMs) {
		return CkRest_Disconnect($this->_cPtr,$maxWaitMs);
	}

	function DisconnectAsync($maxWaitMs) {
		$r=CkRest_DisconnectAsync($this->_cPtr,$maxWaitMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FullRequestBd($httpVerb,$uriPath,$binData,$responseBody) {
		return CkRest_FullRequestBd($this->_cPtr,$httpVerb,$uriPath,$binData,$responseBody);
	}

	function FullRequestBdAsync($httpVerb,$uriPath,$binData,$responseBody) {
		$r=CkRest_FullRequestBdAsync($this->_cPtr,$httpVerb,$uriPath,$binData,$responseBody);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fullRequestBinary($httpVerb,$uriPath,$bodyBytes) {
		return CkRest_fullRequestBinary($this->_cPtr,$httpVerb,$uriPath,$bodyBytes);
	}

	function FullRequestBinaryAsync($httpVerb,$uriPath,$bodyBytes) {
		$r=CkRest_FullRequestBinaryAsync($this->_cPtr,$httpVerb,$uriPath,$bodyBytes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fullRequestFormUrlEncoded($httpVerb,$uriPath) {
		return CkRest_fullRequestFormUrlEncoded($this->_cPtr,$httpVerb,$uriPath);
	}

	function FullRequestFormUrlEncodedAsync($httpVerb,$uriPath) {
		$r=CkRest_FullRequestFormUrlEncodedAsync($this->_cPtr,$httpVerb,$uriPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fullRequestMultipart($httpVerb,$uriPath) {
		return CkRest_fullRequestMultipart($this->_cPtr,$httpVerb,$uriPath);
	}

	function FullRequestMultipartAsync($httpVerb,$uriPath) {
		$r=CkRest_FullRequestMultipartAsync($this->_cPtr,$httpVerb,$uriPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fullRequestNoBody($httpVerb,$uriPath) {
		return CkRest_fullRequestNoBody($this->_cPtr,$httpVerb,$uriPath);
	}

	function FullRequestNoBodyAsync($httpVerb,$uriPath) {
		$r=CkRest_FullRequestNoBodyAsync($this->_cPtr,$httpVerb,$uriPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FullRequestNoBodyBd($httpVerb,$uriPath,$binData) {
		return CkRest_FullRequestNoBodyBd($this->_cPtr,$httpVerb,$uriPath,$binData);
	}

	function FullRequestNoBodyBdAsync($httpVerb,$uriPath,$binData) {
		$r=CkRest_FullRequestNoBodyBdAsync($this->_cPtr,$httpVerb,$uriPath,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FullRequestNoBodySb($httpVerb,$uriPath,$sb) {
		return CkRest_FullRequestNoBodySb($this->_cPtr,$httpVerb,$uriPath,$sb);
	}

	function FullRequestNoBodySbAsync($httpVerb,$uriPath,$sb) {
		$r=CkRest_FullRequestNoBodySbAsync($this->_cPtr,$httpVerb,$uriPath,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FullRequestSb($httpVerb,$uriPath,$requestBody,$responseBody) {
		return CkRest_FullRequestSb($this->_cPtr,$httpVerb,$uriPath,$requestBody,$responseBody);
	}

	function FullRequestSbAsync($httpVerb,$uriPath,$requestBody,$responseBody) {
		$r=CkRest_FullRequestSbAsync($this->_cPtr,$httpVerb,$uriPath,$requestBody,$responseBody);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fullRequestStream($httpVerb,$uriPath,$stream) {
		return CkRest_fullRequestStream($this->_cPtr,$httpVerb,$uriPath,$stream);
	}

	function FullRequestStreamAsync($httpVerb,$uriPath,$stream) {
		$r=CkRest_FullRequestStreamAsync($this->_cPtr,$httpVerb,$uriPath,$stream);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fullRequestString($httpVerb,$uriPath,$bodyText) {
		return CkRest_fullRequestString($this->_cPtr,$httpVerb,$uriPath,$bodyText);
	}

	function FullRequestStringAsync($httpVerb,$uriPath,$bodyText) {
		$r=CkRest_FullRequestStringAsync($this->_cPtr,$httpVerb,$uriPath,$bodyText);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetLastDebugRequest($bd) {
		return CkRest_GetLastDebugRequest($this->_cPtr,$bd);
	}

	function GetLastJsonData($json) {
		CkRest_GetLastJsonData($this->_cPtr,$json);
	}

	function LastJsonData() {
		$r=CkRest_LastJsonData($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkRest_LoadTaskCaller($this->_cPtr,$task);
	}

	function ReadRespBd($responseBody) {
		return CkRest_ReadRespBd($this->_cPtr,$responseBody);
	}

	function ReadRespBdAsync($responseBody) {
		$r=CkRest_ReadRespBdAsync($this->_cPtr,$responseBody);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadRespBodyBinary($outBytes) {
		return CkRest_ReadRespBodyBinary($this->_cPtr,$outBytes);
	}

	function ReadRespBodyBinaryAsync() {
		$r=CkRest_ReadRespBodyBinaryAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadRespBodyStream($stream,$autoSetStreamCharset) {
		return CkRest_ReadRespBodyStream($this->_cPtr,$stream,$autoSetStreamCharset);
	}

	function ReadRespBodyStreamAsync($stream,$autoSetStreamCharset) {
		$r=CkRest_ReadRespBodyStreamAsync($this->_cPtr,$stream,$autoSetStreamCharset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function readRespBodyString() {
		return CkRest_readRespBodyString($this->_cPtr);
	}

	function ReadRespBodyStringAsync() {
		$r=CkRest_ReadRespBodyStringAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadRespChunkBd($minSize,$bd) {
		return CkRest_ReadRespChunkBd($this->_cPtr,$minSize,$bd);
	}

	function ReadRespChunkBdAsync($minSize,$bd) {
		$r=CkRest_ReadRespChunkBdAsync($this->_cPtr,$minSize,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadResponseHeader() {
		return CkRest_ReadResponseHeader($this->_cPtr);
	}

	function ReadResponseHeaderAsync() {
		$r=CkRest_ReadResponseHeaderAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadRespSb($responseBody) {
		return CkRest_ReadRespSb($this->_cPtr,$responseBody);
	}

	function ReadRespSbAsync($responseBody) {
		$r=CkRest_ReadRespSbAsync($this->_cPtr,$responseBody);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RedirectUrl() {
		$r=CkRest_RedirectUrl($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkUrl($r);
		}
		return $r;
	}

	function RemoveHeader($name) {
		return CkRest_RemoveHeader($this->_cPtr,$name);
	}

	function RemoveQueryParam($name) {
		return CkRest_RemoveQueryParam($this->_cPtr,$name);
	}

	function responseHdrByName($name) {
		return CkRest_responseHdrByName($this->_cPtr,$name);
	}

	function responseHdrName($index) {
		return CkRest_responseHdrName($this->_cPtr,$index);
	}

	function responseHdrValue($index) {
		return CkRest_responseHdrValue($this->_cPtr,$index);
	}

	function SendReqBd($httpVerb,$uriPath,$body) {
		return CkRest_SendReqBd($this->_cPtr,$httpVerb,$uriPath,$body);
	}

	function SendReqBdAsync($httpVerb,$uriPath,$body) {
		$r=CkRest_SendReqBdAsync($this->_cPtr,$httpVerb,$uriPath,$body);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqBinaryBody($httpVerb,$uriPath,$body) {
		return CkRest_SendReqBinaryBody($this->_cPtr,$httpVerb,$uriPath,$body);
	}

	function SendReqBinaryBodyAsync($httpVerb,$uriPath,$body) {
		$r=CkRest_SendReqBinaryBodyAsync($this->_cPtr,$httpVerb,$uriPath,$body);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqFormUrlEncoded($httpVerb,$uriPath) {
		return CkRest_SendReqFormUrlEncoded($this->_cPtr,$httpVerb,$uriPath);
	}

	function SendReqFormUrlEncodedAsync($httpVerb,$uriPath) {
		$r=CkRest_SendReqFormUrlEncodedAsync($this->_cPtr,$httpVerb,$uriPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqMultipart($httpVerb,$uriPath) {
		return CkRest_SendReqMultipart($this->_cPtr,$httpVerb,$uriPath);
	}

	function SendReqMultipartAsync($httpVerb,$uriPath) {
		$r=CkRest_SendReqMultipartAsync($this->_cPtr,$httpVerb,$uriPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqNoBody($httpVerb,$uriPath) {
		return CkRest_SendReqNoBody($this->_cPtr,$httpVerb,$uriPath);
	}

	function SendReqNoBodyAsync($httpVerb,$uriPath) {
		$r=CkRest_SendReqNoBodyAsync($this->_cPtr,$httpVerb,$uriPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqSb($httpVerb,$uriPath,$bodySb) {
		return CkRest_SendReqSb($this->_cPtr,$httpVerb,$uriPath,$bodySb);
	}

	function SendReqSbAsync($httpVerb,$uriPath,$bodySb) {
		$r=CkRest_SendReqSbAsync($this->_cPtr,$httpVerb,$uriPath,$bodySb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqStreamBody($httpVerb,$uriPath,$stream) {
		return CkRest_SendReqStreamBody($this->_cPtr,$httpVerb,$uriPath,$stream);
	}

	function SendReqStreamBodyAsync($httpVerb,$uriPath,$stream) {
		$r=CkRest_SendReqStreamBodyAsync($this->_cPtr,$httpVerb,$uriPath,$stream);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqStringBody($httpVerb,$uriPath,$bodyText) {
		return CkRest_SendReqStringBody($this->_cPtr,$httpVerb,$uriPath,$bodyText);
	}

	function SendReqStringBodyAsync($httpVerb,$uriPath,$bodyText) {
		$r=CkRest_SendReqStringBodyAsync($this->_cPtr,$httpVerb,$uriPath,$bodyText);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetAuthAws($authProvider) {
		return CkRest_SetAuthAws($this->_cPtr,$authProvider);
	}

	function SetAuthAzureSas($authProvider) {
		return CkRest_SetAuthAzureSas($this->_cPtr,$authProvider);
	}

	function SetAuthAzureStorage($authProvider) {
		return CkRest_SetAuthAzureStorage($this->_cPtr,$authProvider);
	}

	function SetAuthBasic($username,$password) {
		return CkRest_SetAuthBasic($this->_cPtr,$username,$password);
	}

	function SetAuthBasicSecure($username,$password) {
		return CkRest_SetAuthBasicSecure($this->_cPtr,$username,$password);
	}

	function SetAuthGoogle($authProvider) {
		return CkRest_SetAuthGoogle($this->_cPtr,$authProvider);
	}

	function SetAuthOAuth1($authProvider,$useQueryParams) {
		return CkRest_SetAuthOAuth1($this->_cPtr,$authProvider,$useQueryParams);
	}

	function SetAuthOAuth2($authProvider) {
		return CkRest_SetAuthOAuth2($this->_cPtr,$authProvider);
	}

	function SetMultipartBodyBd($bodyData) {
		return CkRest_SetMultipartBodyBd($this->_cPtr,$bodyData);
	}

	function SetMultipartBodyBinary($bodyData) {
		return CkRest_SetMultipartBodyBinary($this->_cPtr,$bodyData);
	}

	function SetMultipartBodySb($bodySb) {
		return CkRest_SetMultipartBodySb($this->_cPtr,$bodySb);
	}

	function SetMultipartBodyStream($stream) {
		return CkRest_SetMultipartBodyStream($this->_cPtr,$stream);
	}

	function SetMultipartBodyString($bodyText) {
		return CkRest_SetMultipartBodyString($this->_cPtr,$bodyText);
	}

	function SetResponseBodyStream($expectedStatus,$autoSetStreamCharset,$responseStream) {
		return CkRest_SetResponseBodyStream($this->_cPtr,$expectedStatus,$autoSetStreamCharset,$responseStream);
	}

	function UseConnection($connection,$autoReconnect) {
		return CkRest_UseConnection($this->_cPtr,$connection,$autoReconnect);
	}
}

class CkRsa {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkRsa') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkRsa();
	}

	function get_Utf8() {
		return CkRsa_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkRsa_put_Utf8($this->_cPtr,$b);
	}

	function get_Charset($str) {
		CkRsa_get_Charset($this->_cPtr,$str);
	}

	function charset() {
		return CkRsa_charset($this->_cPtr);
	}

	function put_Charset($newVal) {
		CkRsa_put_Charset($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkRsa_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkRsa_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkRsa_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EncodingMode($str) {
		CkRsa_get_EncodingMode($this->_cPtr,$str);
	}

	function encodingMode() {
		return CkRsa_encodingMode($this->_cPtr);
	}

	function put_EncodingMode($newVal) {
		CkRsa_put_EncodingMode($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkRsa_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkRsa_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkRsa_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkRsa_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkRsa_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkRsa_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkRsa_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkRsa_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LittleEndian() {
		return CkRsa_get_LittleEndian($this->_cPtr);
	}

	function put_LittleEndian($newVal) {
		CkRsa_put_LittleEndian($this->_cPtr,$newVal);
	}

	function get_NoUnpad() {
		return CkRsa_get_NoUnpad($this->_cPtr);
	}

	function put_NoUnpad($newVal) {
		CkRsa_put_NoUnpad($this->_cPtr,$newVal);
	}

	function get_NumBits() {
		return CkRsa_get_NumBits($this->_cPtr);
	}

	function get_OaepHash($str) {
		CkRsa_get_OaepHash($this->_cPtr,$str);
	}

	function oaepHash() {
		return CkRsa_oaepHash($this->_cPtr);
	}

	function put_OaepHash($newVal) {
		CkRsa_put_OaepHash($this->_cPtr,$newVal);
	}

	function get_OaepLabel($str) {
		CkRsa_get_OaepLabel($this->_cPtr,$str);
	}

	function oaepLabel() {
		return CkRsa_oaepLabel($this->_cPtr);
	}

	function put_OaepLabel($newVal) {
		CkRsa_put_OaepLabel($this->_cPtr,$newVal);
	}

	function get_OaepMgfHash($str) {
		CkRsa_get_OaepMgfHash($this->_cPtr,$str);
	}

	function oaepMgfHash() {
		return CkRsa_oaepMgfHash($this->_cPtr);
	}

	function put_OaepMgfHash($newVal) {
		CkRsa_put_OaepMgfHash($this->_cPtr,$newVal);
	}

	function get_OaepPadding() {
		return CkRsa_get_OaepPadding($this->_cPtr);
	}

	function put_OaepPadding($newVal) {
		CkRsa_put_OaepPadding($this->_cPtr,$newVal);
	}

	function get_PkcsPadding() {
		return CkRsa_get_PkcsPadding($this->_cPtr);
	}

	function put_PkcsPadding($newVal) {
		CkRsa_put_PkcsPadding($this->_cPtr,$newVal);
	}

	function get_PssSaltLen() {
		return CkRsa_get_PssSaltLen($this->_cPtr);
	}

	function put_PssSaltLen($newVal) {
		CkRsa_put_PssSaltLen($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkRsa_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkRsa_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkRsa_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkRsa_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkRsa_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkRsa_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkRsa_version($this->_cPtr);
	}

	function DecryptBd($bd,$usePrivateKey) {
		return CkRsa_DecryptBd($this->_cPtr,$bd,$usePrivateKey);
	}

	function DecryptBytes($inData,$usePrivateKey,$outData) {
		return CkRsa_DecryptBytes($this->_cPtr,$inData,$usePrivateKey,$outData);
	}

	function DecryptBytesENC($str,$bUsePrivateKey,$outData) {
		return CkRsa_DecryptBytesENC($this->_cPtr,$str,$bUsePrivateKey,$outData);
	}

	function decryptString($encBytes,$usePrivateKey) {
		return CkRsa_decryptString($this->_cPtr,$encBytes,$usePrivateKey);
	}

	function decryptStringENC($str,$usePrivateKey) {
		return CkRsa_decryptStringENC($this->_cPtr,$str,$usePrivateKey);
	}

	function EncryptBd($bd,$usePrivateKey) {
		return CkRsa_EncryptBd($this->_cPtr,$bd,$usePrivateKey);
	}

	function EncryptBytes($binaryData,$usePrivateKey,$outData) {
		return CkRsa_EncryptBytes($this->_cPtr,$binaryData,$usePrivateKey,$outData);
	}

	function encryptBytesENC($data,$bUsePrivateKey) {
		return CkRsa_encryptBytesENC($this->_cPtr,$data,$bUsePrivateKey);
	}

	function EncryptString($stringToEncrypt,$usePrivateKey,$outData) {
		return CkRsa_EncryptString($this->_cPtr,$stringToEncrypt,$usePrivateKey,$outData);
	}

	function encryptStringENC($str,$bUsePrivateKey) {
		return CkRsa_encryptStringENC($this->_cPtr,$str,$bUsePrivateKey);
	}

	function exportPrivateKey() {
		return CkRsa_exportPrivateKey($this->_cPtr);
	}

	function ExportPrivateKeyObj() {
		$r=CkRsa_ExportPrivateKeyObj($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPrivateKey($r);
		}
		return $r;
	}

	function exportPublicKey() {
		return CkRsa_exportPublicKey($this->_cPtr);
	}

	function ExportPublicKeyObj() {
		$r=CkRsa_ExportPublicKeyObj($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPublicKey($r);
		}
		return $r;
	}

	function GenerateKey($numBits) {
		return CkRsa_GenerateKey($this->_cPtr,$numBits);
	}

	function GenKey($numBits,$privKey) {
		return CkRsa_GenKey($this->_cPtr,$numBits,$privKey);
	}

	function ImportPrivateKey($xmlKey) {
		return CkRsa_ImportPrivateKey($this->_cPtr,$xmlKey);
	}

	function ImportPrivateKeyObj($key) {
		return CkRsa_ImportPrivateKeyObj($this->_cPtr,$key);
	}

	function ImportPublicKey($xmlKey) {
		return CkRsa_ImportPublicKey($this->_cPtr,$xmlKey);
	}

	function ImportPublicKeyObj($key) {
		return CkRsa_ImportPublicKeyObj($this->_cPtr,$key);
	}

	function OpenSslSignBd($bd) {
		return CkRsa_OpenSslSignBd($this->_cPtr,$bd);
	}

	function OpenSslSignBytes($data,$outBytes) {
		return CkRsa_OpenSslSignBytes($this->_cPtr,$data,$outBytes);
	}

	function openSslSignBytesENC($data) {
		return CkRsa_openSslSignBytesENC($this->_cPtr,$data);
	}

	function OpenSslSignString($str,$outBytes) {
		return CkRsa_OpenSslSignString($this->_cPtr,$str,$outBytes);
	}

	function openSslSignStringENC($str) {
		return CkRsa_openSslSignStringENC($this->_cPtr,$str);
	}

	function OpenSslVerifyBd($bd) {
		return CkRsa_OpenSslVerifyBd($this->_cPtr,$bd);
	}

	function OpenSslVerifyBytes($signature,$outBytes) {
		return CkRsa_OpenSslVerifyBytes($this->_cPtr,$signature,$outBytes);
	}

	function OpenSslVerifyBytesENC($str,$outBytes) {
		return CkRsa_OpenSslVerifyBytesENC($this->_cPtr,$str,$outBytes);
	}

	function openSslVerifyString($data) {
		return CkRsa_openSslVerifyString($this->_cPtr,$data);
	}

	function openSslVerifyStringENC($str) {
		return CkRsa_openSslVerifyStringENC($this->_cPtr,$str);
	}

	function SetX509Cert($cert,$usePrivateKey) {
		return CkRsa_SetX509Cert($this->_cPtr,$cert,$usePrivateKey);
	}

	function SignBd($bdData,$hashAlgorithm,$bdSig) {
		return CkRsa_SignBd($this->_cPtr,$bdData,$hashAlgorithm,$bdSig);
	}

	function SignBytes($binaryData,$hashAlgorithm,$outData) {
		return CkRsa_SignBytes($this->_cPtr,$binaryData,$hashAlgorithm,$outData);
	}

	function signBytesENC($binaryData,$hashAlgorithm) {
		return CkRsa_signBytesENC($this->_cPtr,$binaryData,$hashAlgorithm);
	}

	function SignHash($hashBytes,$hashAlg,$outBytes) {
		return CkRsa_SignHash($this->_cPtr,$hashBytes,$hashAlg,$outBytes);
	}

	function signHashENC($encodedHash,$hashAlg) {
		return CkRsa_signHashENC($this->_cPtr,$encodedHash,$hashAlg);
	}

	function SignRawBd($bd) {
		return CkRsa_SignRawBd($this->_cPtr,$bd);
	}

	function SignString($strToBeHashed,$hashAlgorithm,$outData) {
		return CkRsa_SignString($this->_cPtr,$strToBeHashed,$hashAlgorithm,$outData);
	}

	function signStringENC($strToBeHashed,$hashAlgorithm) {
		return CkRsa_signStringENC($this->_cPtr,$strToBeHashed,$hashAlgorithm);
	}

	function snkToXml($filename) {
		return CkRsa_snkToXml($this->_cPtr,$filename);
	}

	function UsePrivateKey($privKey) {
		return CkRsa_UsePrivateKey($this->_cPtr,$privKey);
	}

	function UsePublicKey($pubKey) {
		return CkRsa_UsePublicKey($this->_cPtr,$pubKey);
	}

	function VerifyBd($bdData,$hashAlgorithm,$bdSig) {
		return CkRsa_VerifyBd($this->_cPtr,$bdData,$hashAlgorithm,$bdSig);
	}

	function VerifyBytes($originalData,$hashAlgorithm,$signatureBytes) {
		return CkRsa_VerifyBytes($this->_cPtr,$originalData,$hashAlgorithm,$signatureBytes);
	}

	function VerifyBytesENC($originalData,$hashAlgorithm,$encodedSig) {
		return CkRsa_VerifyBytesENC($this->_cPtr,$originalData,$hashAlgorithm,$encodedSig);
	}

	function VerifyHash($hashBytes,$hashAlg,$sigBytes) {
		return CkRsa_VerifyHash($this->_cPtr,$hashBytes,$hashAlg,$sigBytes);
	}

	function VerifyHashENC($encodedHash,$hashAlg,$encodedSig) {
		return CkRsa_VerifyHashENC($this->_cPtr,$encodedHash,$hashAlg,$encodedSig);
	}

	function VerifyRawBd($bd) {
		return CkRsa_VerifyRawBd($this->_cPtr,$bd);
	}

	function VerifyString($originalString,$hashAlgorithm,$binarySig) {
		return CkRsa_VerifyString($this->_cPtr,$originalString,$hashAlgorithm,$binarySig);
	}

	function VerifyStringENC($originalString,$hashAlgorithm,$encodedSig) {
		return CkRsa_VerifyStringENC($this->_cPtr,$originalString,$hashAlgorithm,$encodedSig);
	}
}

class CkSCard {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSCard') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSCard();
	}

	function get_Utf8() {
		return CkSCard_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSCard_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkSCard_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_ActiveProtocol($str) {
		CkSCard_get_ActiveProtocol($this->_cPtr,$str);
	}

	function activeProtocol() {
		return CkSCard_activeProtocol($this->_cPtr);
	}

	function get_CardAtr($str) {
		CkSCard_get_CardAtr($this->_cPtr,$str);
	}

	function cardAtr() {
		return CkSCard_cardAtr($this->_cPtr);
	}

	function get_ConnectedReader($str) {
		CkSCard_get_ConnectedReader($this->_cPtr,$str);
	}

	function connectedReader() {
		return CkSCard_connectedReader($this->_cPtr);
	}

	function get_Context($str) {
		CkSCard_get_Context($this->_cPtr,$str);
	}

	function context() {
		return CkSCard_context($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkSCard_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSCard_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSCard_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkSCard_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSCard_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSCard_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSCard_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSCard_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSCard_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSCard_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSCard_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_PcscLibPath($str) {
		CkSCard_get_PcscLibPath($this->_cPtr,$str);
	}

	function pcscLibPath() {
		return CkSCard_pcscLibPath($this->_cPtr);
	}

	function put_PcscLibPath($newVal) {
		CkSCard_put_PcscLibPath($this->_cPtr,$newVal);
	}

	function get_ReaderStatus($str) {
		CkSCard_get_ReaderStatus($this->_cPtr,$str);
	}

	function readerStatus() {
		return CkSCard_readerStatus($this->_cPtr);
	}

	function get_ScardError($str) {
		CkSCard_get_ScardError($this->_cPtr,$str);
	}

	function scardError() {
		return CkSCard_scardError($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkSCard_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSCard_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSCard_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSCard_version($this->_cPtr);
	}

	function BeginTransaction() {
		return CkSCard_BeginTransaction($this->_cPtr);
	}

	function CheckStatus() {
		return CkSCard_CheckStatus($this->_cPtr);
	}

	function Connect($reader,$shareMode,$preferredProtocol) {
		return CkSCard_Connect($this->_cPtr,$reader,$shareMode,$preferredProtocol);
	}

	function Disconnect($disposition) {
		return CkSCard_Disconnect($this->_cPtr,$disposition);
	}

	function EndTransaction($disposition) {
		return CkSCard_EndTransaction($this->_cPtr,$disposition);
	}

	function EstablishContext($scope) {
		return CkSCard_EstablishContext($this->_cPtr,$scope);
	}

	function FindSmartcards($json) {
		return CkSCard_FindSmartcards($this->_cPtr,$json);
	}

	function GetAttrib($attr,$bd) {
		return CkSCard_GetAttrib($this->_cPtr,$attr,$bd);
	}

	function getAttribStr($attr) {
		return CkSCard_getAttribStr($this->_cPtr,$attr);
	}

	function attribStr($attr) {
		return CkSCard_attribStr($this->_cPtr,$attr);
	}

	function GetAttribUint($attr) {
		return CkSCard_GetAttribUint($this->_cPtr,$attr);
	}

	function GetStatusChange($maxWaitMs,$stReaderNames,$json) {
		return CkSCard_GetStatusChange($this->_cPtr,$maxWaitMs,$stReaderNames,$json);
	}

	function GetStatusChangeAsync($maxWaitMs,$stReaderNames,$json) {
		$r=CkSCard_GetStatusChangeAsync($this->_cPtr,$maxWaitMs,$stReaderNames,$json);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetStatusChangeCancel() {
		return CkSCard_GetStatusChangeCancel($this->_cPtr);
	}

	function ListReaderGroups($readerGroups) {
		return CkSCard_ListReaderGroups($this->_cPtr,$readerGroups);
	}

	function ListReaders($st) {
		return CkSCard_ListReaders($this->_cPtr,$st);
	}

	function Reconnect($shareMode,$preferredProtocol,$action) {
		return CkSCard_Reconnect($this->_cPtr,$shareMode,$preferredProtocol,$action);
	}

	function ReleaseContext() {
		return CkSCard_ReleaseContext($this->_cPtr);
	}

	function SendControl($controlCode,$bdSend,$bdRecv) {
		return CkSCard_SendControl($this->_cPtr,$controlCode,$bdSend,$bdRecv);
	}

	function SendControlHex($controlCode,$sendData,$bdRecv) {
		return CkSCard_SendControlHex($this->_cPtr,$controlCode,$sendData,$bdRecv);
	}

	function Transmit($protocol,$bdSend,$bdRecv,$maxRecvLen) {
		return CkSCard_Transmit($this->_cPtr,$protocol,$bdSend,$bdRecv,$maxRecvLen);
	}

	function TransmitHex($protocol,$apduHex,$bdRecv,$maxRecvLen) {
		return CkSCard_TransmitHex($this->_cPtr,$protocol,$apduHex,$bdRecv,$maxRecvLen);
	}
}

class CkSFtp {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSFtp') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSFtp();
	}

	function get_Utf8() {
		return CkSFtp_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSFtp_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkSFtp_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkSFtp_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkSFtp_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_AuthFailReason() {
		return CkSFtp_get_AuthFailReason($this->_cPtr);
	}

	function get_BandwidthThrottleDown() {
		return CkSFtp_get_BandwidthThrottleDown($this->_cPtr);
	}

	function put_BandwidthThrottleDown($newVal) {
		CkSFtp_put_BandwidthThrottleDown($this->_cPtr,$newVal);
	}

	function get_BandwidthThrottleUp() {
		return CkSFtp_get_BandwidthThrottleUp($this->_cPtr);
	}

	function put_BandwidthThrottleUp($newVal) {
		CkSFtp_put_BandwidthThrottleUp($this->_cPtr,$newVal);
	}

	function get_ClientIdentifier($str) {
		CkSFtp_get_ClientIdentifier($this->_cPtr,$str);
	}

	function clientIdentifier() {
		return CkSFtp_clientIdentifier($this->_cPtr);
	}

	function put_ClientIdentifier($newVal) {
		CkSFtp_put_ClientIdentifier($this->_cPtr,$newVal);
	}

	function get_ClientIpAddress($str) {
		CkSFtp_get_ClientIpAddress($this->_cPtr,$str);
	}

	function clientIpAddress() {
		return CkSFtp_clientIpAddress($this->_cPtr);
	}

	function put_ClientIpAddress($newVal) {
		CkSFtp_put_ClientIpAddress($this->_cPtr,$newVal);
	}

	function get_ConnectTimeoutMs() {
		return CkSFtp_get_ConnectTimeoutMs($this->_cPtr);
	}

	function put_ConnectTimeoutMs($newVal) {
		CkSFtp_put_ConnectTimeoutMs($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkSFtp_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSFtp_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSFtp_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DisconnectCode() {
		return CkSFtp_get_DisconnectCode($this->_cPtr);
	}

	function get_DisconnectReason($str) {
		CkSFtp_get_DisconnectReason($this->_cPtr,$str);
	}

	function disconnectReason() {
		return CkSFtp_disconnectReason($this->_cPtr);
	}

	function get_EnableCache() {
		return CkSFtp_get_EnableCache($this->_cPtr);
	}

	function put_EnableCache($newVal) {
		CkSFtp_put_EnableCache($this->_cPtr,$newVal);
	}

	function get_EnableCompression() {
		return CkSFtp_get_EnableCompression($this->_cPtr);
	}

	function put_EnableCompression($newVal) {
		CkSFtp_put_EnableCompression($this->_cPtr,$newVal);
	}

	function get_FilenameCharset($str) {
		CkSFtp_get_FilenameCharset($this->_cPtr,$str);
	}

	function filenameCharset() {
		return CkSFtp_filenameCharset($this->_cPtr);
	}

	function put_FilenameCharset($newVal) {
		CkSFtp_put_FilenameCharset($this->_cPtr,$newVal);
	}

	function get_ForceCipher($str) {
		CkSFtp_get_ForceCipher($this->_cPtr,$str);
	}

	function forceCipher() {
		return CkSFtp_forceCipher($this->_cPtr);
	}

	function put_ForceCipher($newVal) {
		CkSFtp_put_ForceCipher($this->_cPtr,$newVal);
	}

	function get_ForceV3() {
		return CkSFtp_get_ForceV3($this->_cPtr);
	}

	function put_ForceV3($newVal) {
		CkSFtp_put_ForceV3($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkSFtp_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkSFtp_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_HostKeyAlg($str) {
		CkSFtp_get_HostKeyAlg($this->_cPtr,$str);
	}

	function hostKeyAlg() {
		return CkSFtp_hostKeyAlg($this->_cPtr);
	}

	function put_HostKeyAlg($newVal) {
		CkSFtp_put_HostKeyAlg($this->_cPtr,$newVal);
	}

	function get_HostKeyFingerprint($str) {
		CkSFtp_get_HostKeyFingerprint($this->_cPtr,$str);
	}

	function hostKeyFingerprint() {
		return CkSFtp_hostKeyFingerprint($this->_cPtr);
	}

	function get_HttpProxyAuthMethod($str) {
		CkSFtp_get_HttpProxyAuthMethod($this->_cPtr,$str);
	}

	function httpProxyAuthMethod() {
		return CkSFtp_httpProxyAuthMethod($this->_cPtr);
	}

	function put_HttpProxyAuthMethod($newVal) {
		CkSFtp_put_HttpProxyAuthMethod($this->_cPtr,$newVal);
	}

	function get_HttpProxyDomain($str) {
		CkSFtp_get_HttpProxyDomain($this->_cPtr,$str);
	}

	function httpProxyDomain() {
		return CkSFtp_httpProxyDomain($this->_cPtr);
	}

	function put_HttpProxyDomain($newVal) {
		CkSFtp_put_HttpProxyDomain($this->_cPtr,$newVal);
	}

	function get_HttpProxyHostname($str) {
		CkSFtp_get_HttpProxyHostname($this->_cPtr,$str);
	}

	function httpProxyHostname() {
		return CkSFtp_httpProxyHostname($this->_cPtr);
	}

	function put_HttpProxyHostname($newVal) {
		CkSFtp_put_HttpProxyHostname($this->_cPtr,$newVal);
	}

	function get_HttpProxyPassword($str) {
		CkSFtp_get_HttpProxyPassword($this->_cPtr,$str);
	}

	function httpProxyPassword() {
		return CkSFtp_httpProxyPassword($this->_cPtr);
	}

	function put_HttpProxyPassword($newVal) {
		CkSFtp_put_HttpProxyPassword($this->_cPtr,$newVal);
	}

	function get_HttpProxyPort() {
		return CkSFtp_get_HttpProxyPort($this->_cPtr);
	}

	function put_HttpProxyPort($newVal) {
		CkSFtp_put_HttpProxyPort($this->_cPtr,$newVal);
	}

	function get_HttpProxyUsername($str) {
		CkSFtp_get_HttpProxyUsername($this->_cPtr,$str);
	}

	function httpProxyUsername() {
		return CkSFtp_httpProxyUsername($this->_cPtr);
	}

	function put_HttpProxyUsername($newVal) {
		CkSFtp_put_HttpProxyUsername($this->_cPtr,$newVal);
	}

	function get_IdleTimeoutMs() {
		return CkSFtp_get_IdleTimeoutMs($this->_cPtr);
	}

	function put_IdleTimeoutMs($newVal) {
		CkSFtp_put_IdleTimeoutMs($this->_cPtr,$newVal);
	}

	function get_IncludeDotDirs() {
		return CkSFtp_get_IncludeDotDirs($this->_cPtr);
	}

	function put_IncludeDotDirs($newVal) {
		CkSFtp_put_IncludeDotDirs($this->_cPtr,$newVal);
	}

	function get_InitializeFailCode() {
		return CkSFtp_get_InitializeFailCode($this->_cPtr);
	}

	function get_InitializeFailReason($str) {
		CkSFtp_get_InitializeFailReason($this->_cPtr,$str);
	}

	function initializeFailReason() {
		return CkSFtp_initializeFailReason($this->_cPtr);
	}

	function get_IsConnected() {
		return CkSFtp_get_IsConnected($this->_cPtr);
	}

	function get_KeepSessionLog() {
		return CkSFtp_get_KeepSessionLog($this->_cPtr);
	}

	function put_KeepSessionLog($newVal) {
		CkSFtp_put_KeepSessionLog($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkSFtp_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSFtp_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSFtp_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSFtp_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSFtp_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSFtp_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSFtp_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSFtp_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LastStatusCode() {
		return CkSFtp_get_LastStatusCode($this->_cPtr);
	}

	function get_LastStatusMessage($str) {
		CkSFtp_get_LastStatusMessage($this->_cPtr,$str);
	}

	function lastStatusMessage() {
		return CkSFtp_lastStatusMessage($this->_cPtr);
	}

	function get_MaxPacketSize() {
		return CkSFtp_get_MaxPacketSize($this->_cPtr);
	}

	function put_MaxPacketSize($newVal) {
		CkSFtp_put_MaxPacketSize($this->_cPtr,$newVal);
	}

	function get_PasswordChangeRequested() {
		return CkSFtp_get_PasswordChangeRequested($this->_cPtr);
	}

	function get_PercentDoneScale() {
		return CkSFtp_get_PercentDoneScale($this->_cPtr);
	}

	function put_PercentDoneScale($newVal) {
		CkSFtp_put_PercentDoneScale($this->_cPtr,$newVal);
	}

	function get_PreferIpv6() {
		return CkSFtp_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkSFtp_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_PreserveDate() {
		return CkSFtp_get_PreserveDate($this->_cPtr);
	}

	function put_PreserveDate($newVal) {
		CkSFtp_put_PreserveDate($this->_cPtr,$newVal);
	}

	function get_ProtocolVersion() {
		return CkSFtp_get_ProtocolVersion($this->_cPtr);
	}

	function get_ReadDirMustMatch($str) {
		CkSFtp_get_ReadDirMustMatch($this->_cPtr,$str);
	}

	function readDirMustMatch() {
		return CkSFtp_readDirMustMatch($this->_cPtr);
	}

	function put_ReadDirMustMatch($newVal) {
		CkSFtp_put_ReadDirMustMatch($this->_cPtr,$newVal);
	}

	function get_ReadDirMustNotMatch($str) {
		CkSFtp_get_ReadDirMustNotMatch($this->_cPtr,$str);
	}

	function readDirMustNotMatch() {
		return CkSFtp_readDirMustNotMatch($this->_cPtr);
	}

	function put_ReadDirMustNotMatch($newVal) {
		CkSFtp_put_ReadDirMustNotMatch($this->_cPtr,$newVal);
	}

	function get_ServerIdentifier($str) {
		CkSFtp_get_ServerIdentifier($this->_cPtr,$str);
	}

	function serverIdentifier() {
		return CkSFtp_serverIdentifier($this->_cPtr);
	}

	function get_SessionLog($str) {
		CkSFtp_get_SessionLog($this->_cPtr,$str);
	}

	function sessionLog() {
		return CkSFtp_sessionLog($this->_cPtr);
	}

	function get_SocksHostname($str) {
		CkSFtp_get_SocksHostname($this->_cPtr,$str);
	}

	function socksHostname() {
		return CkSFtp_socksHostname($this->_cPtr);
	}

	function put_SocksHostname($newVal) {
		CkSFtp_put_SocksHostname($this->_cPtr,$newVal);
	}

	function get_SocksPassword($str) {
		CkSFtp_get_SocksPassword($this->_cPtr,$str);
	}

	function socksPassword() {
		return CkSFtp_socksPassword($this->_cPtr);
	}

	function put_SocksPassword($newVal) {
		CkSFtp_put_SocksPassword($this->_cPtr,$newVal);
	}

	function get_SocksPort() {
		return CkSFtp_get_SocksPort($this->_cPtr);
	}

	function put_SocksPort($newVal) {
		CkSFtp_put_SocksPort($this->_cPtr,$newVal);
	}

	function get_SocksUsername($str) {
		CkSFtp_get_SocksUsername($this->_cPtr,$str);
	}

	function socksUsername() {
		return CkSFtp_socksUsername($this->_cPtr);
	}

	function put_SocksUsername($newVal) {
		CkSFtp_put_SocksUsername($this->_cPtr,$newVal);
	}

	function get_SocksVersion() {
		return CkSFtp_get_SocksVersion($this->_cPtr);
	}

	function put_SocksVersion($newVal) {
		CkSFtp_put_SocksVersion($this->_cPtr,$newVal);
	}

	function get_SoRcvBuf() {
		return CkSFtp_get_SoRcvBuf($this->_cPtr);
	}

	function put_SoRcvBuf($newVal) {
		CkSFtp_put_SoRcvBuf($this->_cPtr,$newVal);
	}

	function get_SoSndBuf() {
		return CkSFtp_get_SoSndBuf($this->_cPtr);
	}

	function put_SoSndBuf($newVal) {
		CkSFtp_put_SoSndBuf($this->_cPtr,$newVal);
	}

	function get_SyncCreateAllLocalDirs() {
		return CkSFtp_get_SyncCreateAllLocalDirs($this->_cPtr);
	}

	function put_SyncCreateAllLocalDirs($newVal) {
		CkSFtp_put_SyncCreateAllLocalDirs($this->_cPtr,$newVal);
	}

	function get_SyncDirectives($str) {
		CkSFtp_get_SyncDirectives($this->_cPtr,$str);
	}

	function syncDirectives() {
		return CkSFtp_syncDirectives($this->_cPtr);
	}

	function put_SyncDirectives($newVal) {
		CkSFtp_put_SyncDirectives($this->_cPtr,$newVal);
	}

	function get_SyncMustMatch($str) {
		CkSFtp_get_SyncMustMatch($this->_cPtr,$str);
	}

	function syncMustMatch() {
		return CkSFtp_syncMustMatch($this->_cPtr);
	}

	function put_SyncMustMatch($newVal) {
		CkSFtp_put_SyncMustMatch($this->_cPtr,$newVal);
	}

	function get_SyncMustMatchDir($str) {
		CkSFtp_get_SyncMustMatchDir($this->_cPtr,$str);
	}

	function syncMustMatchDir() {
		return CkSFtp_syncMustMatchDir($this->_cPtr);
	}

	function put_SyncMustMatchDir($newVal) {
		CkSFtp_put_SyncMustMatchDir($this->_cPtr,$newVal);
	}

	function get_SyncMustNotMatch($str) {
		CkSFtp_get_SyncMustNotMatch($this->_cPtr,$str);
	}

	function syncMustNotMatch() {
		return CkSFtp_syncMustNotMatch($this->_cPtr);
	}

	function put_SyncMustNotMatch($newVal) {
		CkSFtp_put_SyncMustNotMatch($this->_cPtr,$newVal);
	}

	function get_SyncMustNotMatchDir($str) {
		CkSFtp_get_SyncMustNotMatchDir($this->_cPtr,$str);
	}

	function syncMustNotMatchDir() {
		return CkSFtp_syncMustNotMatchDir($this->_cPtr);
	}

	function put_SyncMustNotMatchDir($newVal) {
		CkSFtp_put_SyncMustNotMatchDir($this->_cPtr,$newVal);
	}

	function get_TcpNoDelay() {
		return CkSFtp_get_TcpNoDelay($this->_cPtr);
	}

	function put_TcpNoDelay($newVal) {
		CkSFtp_put_TcpNoDelay($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkSFtp_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkSFtp_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkSFtp_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UploadChunkSize() {
		return CkSFtp_get_UploadChunkSize($this->_cPtr);
	}

	function put_UploadChunkSize($newVal) {
		CkSFtp_put_UploadChunkSize($this->_cPtr,$newVal);
	}

	function get_UserAuthBanner($str) {
		CkSFtp_get_UserAuthBanner($this->_cPtr,$str);
	}

	function userAuthBanner() {
		return CkSFtp_userAuthBanner($this->_cPtr);
	}

	function put_UserAuthBanner($newVal) {
		CkSFtp_put_UserAuthBanner($this->_cPtr,$newVal);
	}

	function get_UtcMode() {
		return CkSFtp_get_UtcMode($this->_cPtr);
	}

	function put_UtcMode($newVal) {
		CkSFtp_put_UtcMode($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkSFtp_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSFtp_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSFtp_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSFtp_version($this->_cPtr);
	}

	function get_XferByteCount() {
		return CkSFtp_get_XferByteCount($this->_cPtr);
	}

	function get_XferByteCount64() {
		return CkSFtp_get_XferByteCount64($this->_cPtr);
	}

	function AccumulateBytes($handle,$maxBytes) {
		return CkSFtp_AccumulateBytes($this->_cPtr,$handle,$maxBytes);
	}

	function AccumulateBytesAsync($handle,$maxBytes) {
		$r=CkSFtp_AccumulateBytesAsync($this->_cPtr,$handle,$maxBytes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function add64($n1,$n2) {
		return CkSFtp_add64($this->_cPtr,$n1,$n2);
	}

	function AuthenticatePk($username,$privateKey) {
		return CkSFtp_AuthenticatePk($this->_cPtr,$username,$privateKey);
	}

	function AuthenticatePkAsync($username,$privateKey) {
		$r=CkSFtp_AuthenticatePkAsync($this->_cPtr,$username,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticatePw($login,$password) {
		return CkSFtp_AuthenticatePw($this->_cPtr,$login,$password);
	}

	function AuthenticatePwAsync($login,$password) {
		$r=CkSFtp_AuthenticatePwAsync($this->_cPtr,$login,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticatePwPk($username,$password,$privateKey) {
		return CkSFtp_AuthenticatePwPk($this->_cPtr,$username,$password,$privateKey);
	}

	function AuthenticatePwPkAsync($username,$password,$privateKey) {
		$r=CkSFtp_AuthenticatePwPkAsync($this->_cPtr,$username,$password,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticateSecPw($login,$password) {
		return CkSFtp_AuthenticateSecPw($this->_cPtr,$login,$password);
	}

	function AuthenticateSecPwAsync($login,$password) {
		$r=CkSFtp_AuthenticateSecPwAsync($this->_cPtr,$login,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticateSecPwPk($username,$password,$privateKey) {
		return CkSFtp_AuthenticateSecPwPk($this->_cPtr,$username,$password,$privateKey);
	}

	function AuthenticateSecPwPkAsync($username,$password,$privateKey) {
		$r=CkSFtp_AuthenticateSecPwPkAsync($this->_cPtr,$username,$password,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ClearAccumulateBuffer() {
		CkSFtp_ClearAccumulateBuffer($this->_cPtr);
	}

	function ClearCache() {
		CkSFtp_ClearCache($this->_cPtr);
	}

	function ClearSessionLog() {
		CkSFtp_ClearSessionLog($this->_cPtr);
	}

	function CloseHandle($handle) {
		return CkSFtp_CloseHandle($this->_cPtr,$handle);
	}

	function CloseHandleAsync($handle) {
		$r=CkSFtp_CloseHandleAsync($this->_cPtr,$handle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Connect($domainName,$port) {
		return CkSFtp_Connect($this->_cPtr,$domainName,$port);
	}

	function ConnectAsync($domainName,$port) {
		$r=CkSFtp_ConnectAsync($this->_cPtr,$domainName,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ConnectThroughSsh($sshConn,$hostname,$port) {
		return CkSFtp_ConnectThroughSsh($this->_cPtr,$sshConn,$hostname,$port);
	}

	function ConnectThroughSshAsync($sshConn,$hostname,$port) {
		$r=CkSFtp_ConnectThroughSshAsync($this->_cPtr,$sshConn,$hostname,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function continueKeyboardAuth($response) {
		return CkSFtp_continueKeyboardAuth($this->_cPtr,$response);
	}

	function ContinueKeyboardAuthAsync($response) {
		$r=CkSFtp_ContinueKeyboardAuthAsync($this->_cPtr,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CopyFileAttr($localFilename,$remoteFilename,$isHandle) {
		return CkSFtp_CopyFileAttr($this->_cPtr,$localFilename,$remoteFilename,$isHandle);
	}

	function CopyFileAttrAsync($localFilename,$remoteFilename,$isHandle) {
		$r=CkSFtp_CopyFileAttrAsync($this->_cPtr,$localFilename,$remoteFilename,$isHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CreateDir($path) {
		return CkSFtp_CreateDir($this->_cPtr,$path);
	}

	function CreateDirAsync($path) {
		$r=CkSFtp_CreateDirAsync($this->_cPtr,$path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Disconnect() {
		CkSFtp_Disconnect($this->_cPtr);
	}

	function DownloadBd($remoteFilePath,$binData) {
		return CkSFtp_DownloadBd($this->_cPtr,$remoteFilePath,$binData);
	}

	function DownloadBdAsync($remoteFilePath,$binData) {
		$r=CkSFtp_DownloadBdAsync($this->_cPtr,$remoteFilePath,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DownloadFile($handle,$toFilename) {
		return CkSFtp_DownloadFile($this->_cPtr,$handle,$toFilename);
	}

	function DownloadFileAsync($handle,$toFilename) {
		$r=CkSFtp_DownloadFileAsync($this->_cPtr,$handle,$toFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DownloadFileByName($remoteFilePath,$localFilePath) {
		return CkSFtp_DownloadFileByName($this->_cPtr,$remoteFilePath,$localFilePath);
	}

	function DownloadFileByNameAsync($remoteFilePath,$localFilePath) {
		$r=CkSFtp_DownloadFileByNameAsync($this->_cPtr,$remoteFilePath,$localFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DownloadSb($remoteFilePath,$charset,$sb) {
		return CkSFtp_DownloadSb($this->_cPtr,$remoteFilePath,$charset,$sb);
	}

	function DownloadSbAsync($remoteFilePath,$charset,$sb) {
		$r=CkSFtp_DownloadSbAsync($this->_cPtr,$remoteFilePath,$charset,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Eof($handle) {
		return CkSFtp_Eof($this->_cPtr,$handle);
	}

	function FileExists($remotePath,$followLinks) {
		return CkSFtp_FileExists($this->_cPtr,$remotePath,$followLinks);
	}

	function FileExistsAsync($remotePath,$followLinks) {
		$r=CkSFtp_FileExistsAsync($this->_cPtr,$remotePath,$followLinks);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Fsync($handle) {
		return CkSFtp_Fsync($this->_cPtr,$handle);
	}

	function FsyncAsync($handle) {
		$r=CkSFtp_FsyncAsync($this->_cPtr,$handle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetFileCreateDt($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileCreateDt($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetFileCreateDtAsync($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileCreateDtAsync($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getFileCreateTimeStr($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_getFileCreateTimeStr($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function fileCreateTimeStr($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_fileCreateTimeStr($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function GetFileCreateTimeStrAsync($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileCreateTimeStrAsync($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getFileGroup($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_getFileGroup($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function fileGroup($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_fileGroup($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function GetFileGroupAsync($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileGroupAsync($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetFileLastAccessDt($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileLastAccessDt($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetFileLastAccessDtAsync($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileLastAccessDtAsync($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getFileLastAccessStr($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_getFileLastAccessStr($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function fileLastAccessStr($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_fileLastAccessStr($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function GetFileLastAccessStrAsync($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileLastAccessStrAsync($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetFileLastModifiedDt($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileLastModifiedDt($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetFileLastModifiedDtAsync($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileLastModifiedDtAsync($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getFileLastModifiedStr($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_getFileLastModifiedStr($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function fileLastModifiedStr($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_fileLastModifiedStr($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function GetFileLastModifiedStrAsync($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileLastModifiedStrAsync($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getFileOwner($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_getFileOwner($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function fileOwner($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_fileOwner($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function GetFileOwnerAsync($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileOwnerAsync($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetFilePermissions($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_GetFilePermissions($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function GetFilePermissionsAsync($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFilePermissionsAsync($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetFileSize32($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_GetFileSize32($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function GetFileSize32Async($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileSize32Async($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetFileSize64Async($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileSize64Async($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getFileSizeStr($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_getFileSizeStr($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function fileSizeStr($pathOrHandle,$bFollowLinks,$bIsHandle) {
		return CkSFtp_fileSizeStr($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
	}

	function GetFileSizeStrAsync($pathOrHandle,$bFollowLinks,$bIsHandle) {
		$r=CkSFtp_GetFileSizeStrAsync($this->_cPtr,$pathOrHandle,$bFollowLinks,$bIsHandle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getHostKeyFP($hashAlg,$includeKeyType,$includeHashName) {
		return CkSFtp_getHostKeyFP($this->_cPtr,$hashAlg,$includeKeyType,$includeHashName);
	}

	function hostKeyFP($hashAlg,$includeKeyType,$includeHashName) {
		return CkSFtp_hostKeyFP($this->_cPtr,$hashAlg,$includeKeyType,$includeHashName);
	}

	function GetLastJsonData($json) {
		CkSFtp_GetLastJsonData($this->_cPtr,$json);
	}

	function GetSyncedFiles($strTab) {
		CkSFtp_GetSyncedFiles($this->_cPtr,$strTab);
	}

	function HardLink($oldPath,$newPath) {
		return CkSFtp_HardLink($this->_cPtr,$oldPath,$newPath);
	}

	function HardLinkAsync($oldPath,$newPath) {
		$r=CkSFtp_HardLinkAsync($this->_cPtr,$oldPath,$newPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function InitializeSftp() {
		return CkSFtp_InitializeSftp($this->_cPtr);
	}

	function InitializeSftpAsync() {
		$r=CkSFtp_InitializeSftpAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LastJsonData() {
		$r=CkSFtp_LastJsonData($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LastReadFailed($handle) {
		return CkSFtp_LastReadFailed($this->_cPtr,$handle);
	}

	function LastReadNumBytes($handle) {
		return CkSFtp_LastReadNumBytes($this->_cPtr,$handle);
	}

	function LoadTaskCaller($task) {
		return CkSFtp_LoadTaskCaller($this->_cPtr,$task);
	}

	function openDir($path) {
		return CkSFtp_openDir($this->_cPtr,$path);
	}

	function OpenDirAsync($path) {
		$r=CkSFtp_OpenDirAsync($this->_cPtr,$path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function openFile($remotePath,$access,$createDisposition) {
		return CkSFtp_openFile($this->_cPtr,$remotePath,$access,$createDisposition);
	}

	function OpenFileAsync($remotePath,$access,$createDisposition) {
		$r=CkSFtp_OpenFileAsync($this->_cPtr,$remotePath,$access,$createDisposition);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadDir($handle) {
		$r=CkSFtp_ReadDir($this->_cPtr,$handle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkSFtpDir($r);
		}
		return $r;
	}

	function ReadDirAsync($handle) {
		$r=CkSFtp_ReadDirAsync($this->_cPtr,$handle);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadDirListing($handle,$dirObj) {
		return CkSFtp_ReadDirListing($this->_cPtr,$handle,$dirObj);
	}

	function ReadDirListingAsync($handle,$dirObj) {
		$r=CkSFtp_ReadDirListingAsync($this->_cPtr,$handle,$dirObj);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadFileBd($handle,$numBytes,$bd) {
		return CkSFtp_ReadFileBd($this->_cPtr,$handle,$numBytes,$bd);
	}

	function ReadFileBdAsync($handle,$numBytes,$bd) {
		$r=CkSFtp_ReadFileBdAsync($this->_cPtr,$handle,$numBytes,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadFileBytes($handle,$numBytes,$outBytes) {
		return CkSFtp_ReadFileBytes($this->_cPtr,$handle,$numBytes,$outBytes);
	}

	function ReadFileBytesAsync($handle,$numBytes) {
		$r=CkSFtp_ReadFileBytesAsync($this->_cPtr,$handle,$numBytes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadFileBytes32($handle,$offset,$numBytes,$outBytes) {
		return CkSFtp_ReadFileBytes32($this->_cPtr,$handle,$offset,$numBytes,$outBytes);
	}

	function ReadFileBytes32Async($handle,$offset,$numBytes) {
		$r=CkSFtp_ReadFileBytes32Async($this->_cPtr,$handle,$offset,$numBytes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadFileBytes64s($handle,$offset,$numBytes,$outBytes) {
		return CkSFtp_ReadFileBytes64s($this->_cPtr,$handle,$offset,$numBytes,$outBytes);
	}

	function ReadFileBytes64sAsync($handle,$offset,$numBytes) {
		$r=CkSFtp_ReadFileBytes64sAsync($this->_cPtr,$handle,$offset,$numBytes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function readFileText($handle,$numBytes,$charset) {
		return CkSFtp_readFileText($this->_cPtr,$handle,$numBytes,$charset);
	}

	function ReadFileTextAsync($handle,$numBytes,$charset) {
		$r=CkSFtp_ReadFileTextAsync($this->_cPtr,$handle,$numBytes,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function readFileText32($handle,$offset,$numBytes,$charset) {
		return CkSFtp_readFileText32($this->_cPtr,$handle,$offset,$numBytes,$charset);
	}

	function ReadFileText32Async($handle,$offset,$numBytes,$charset) {
		$r=CkSFtp_ReadFileText32Async($this->_cPtr,$handle,$offset,$numBytes,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function readFileText64s($handle,$offset,$numBytes,$charset) {
		return CkSFtp_readFileText64s($this->_cPtr,$handle,$offset,$numBytes,$charset);
	}

	function ReadFileText64sAsync($handle,$offset,$numBytes,$charset) {
		$r=CkSFtp_ReadFileText64sAsync($this->_cPtr,$handle,$offset,$numBytes,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function readLink($path) {
		return CkSFtp_readLink($this->_cPtr,$path);
	}

	function ReadLinkAsync($path) {
		$r=CkSFtp_ReadLinkAsync($this->_cPtr,$path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function realPath($originalPath,$composePath) {
		return CkSFtp_realPath($this->_cPtr,$originalPath,$composePath);
	}

	function RealPathAsync($originalPath,$composePath) {
		$r=CkSFtp_RealPathAsync($this->_cPtr,$originalPath,$composePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RemoveDir($path) {
		return CkSFtp_RemoveDir($this->_cPtr,$path);
	}

	function RemoveDirAsync($path) {
		$r=CkSFtp_RemoveDirAsync($this->_cPtr,$path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RemoveFile($filename) {
		return CkSFtp_RemoveFile($this->_cPtr,$filename);
	}

	function RemoveFileAsync($filename) {
		$r=CkSFtp_RemoveFileAsync($this->_cPtr,$filename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RenameFileOrDir($oldPath,$newPath) {
		return CkSFtp_RenameFileOrDir($this->_cPtr,$oldPath,$newPath);
	}

	function RenameFileOrDirAsync($oldPath,$newPath) {
		$r=CkSFtp_RenameFileOrDirAsync($this->_cPtr,$oldPath,$newPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ResumeDownloadFileByName($remoteFilePath,$localFilePath) {
		return CkSFtp_ResumeDownloadFileByName($this->_cPtr,$remoteFilePath,$localFilePath);
	}

	function ResumeDownloadFileByNameAsync($remoteFilePath,$localFilePath) {
		$r=CkSFtp_ResumeDownloadFileByNameAsync($this->_cPtr,$remoteFilePath,$localFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ResumeUploadFileByName($remoteFilePath,$localFilePath) {
		return CkSFtp_ResumeUploadFileByName($this->_cPtr,$remoteFilePath,$localFilePath);
	}

	function ResumeUploadFileByNameAsync($remoteFilePath,$localFilePath) {
		$r=CkSFtp_ResumeUploadFileByNameAsync($this->_cPtr,$remoteFilePath,$localFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendIgnore() {
		return CkSFtp_SendIgnore($this->_cPtr);
	}

	function SendIgnoreAsync() {
		$r=CkSFtp_SendIgnoreAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetAllowedAlgorithms($json) {
		return CkSFtp_SetAllowedAlgorithms($this->_cPtr,$json);
	}

	function SetCreateDt($pathOrHandle,$isHandle,$createDateTime) {
		return CkSFtp_SetCreateDt($this->_cPtr,$pathOrHandle,$isHandle,$createDateTime);
	}

	function SetCreateDtAsync($pathOrHandle,$isHandle,$createDateTime) {
		$r=CkSFtp_SetCreateDtAsync($this->_cPtr,$pathOrHandle,$isHandle,$createDateTime);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetCreateTimeStr($pathOrHandle,$bIsHandle,$dateTimeStr) {
		return CkSFtp_SetCreateTimeStr($this->_cPtr,$pathOrHandle,$bIsHandle,$dateTimeStr);
	}

	function SetCreateTimeStrAsync($pathOrHandle,$bIsHandle,$dateTimeStr) {
		$r=CkSFtp_SetCreateTimeStrAsync($this->_cPtr,$pathOrHandle,$bIsHandle,$dateTimeStr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetLastAccessDt($pathOrHandle,$isHandle,$accessDateTime) {
		return CkSFtp_SetLastAccessDt($this->_cPtr,$pathOrHandle,$isHandle,$accessDateTime);
	}

	function SetLastAccessDtAsync($pathOrHandle,$isHandle,$accessDateTime) {
		$r=CkSFtp_SetLastAccessDtAsync($this->_cPtr,$pathOrHandle,$isHandle,$accessDateTime);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetLastAccessTimeStr($pathOrHandle,$bIsHandle,$dateTimeStr) {
		return CkSFtp_SetLastAccessTimeStr($this->_cPtr,$pathOrHandle,$bIsHandle,$dateTimeStr);
	}

	function SetLastAccessTimeStrAsync($pathOrHandle,$bIsHandle,$dateTimeStr) {
		$r=CkSFtp_SetLastAccessTimeStrAsync($this->_cPtr,$pathOrHandle,$bIsHandle,$dateTimeStr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetLastModifiedDt($pathOrHandle,$isHandle,$modifiedDateTime) {
		return CkSFtp_SetLastModifiedDt($this->_cPtr,$pathOrHandle,$isHandle,$modifiedDateTime);
	}

	function SetLastModifiedDtAsync($pathOrHandle,$isHandle,$modifiedDateTime) {
		$r=CkSFtp_SetLastModifiedDtAsync($this->_cPtr,$pathOrHandle,$isHandle,$modifiedDateTime);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetLastModifiedTimeStr($pathOrHandle,$bIsHandle,$dateTimeStr) {
		return CkSFtp_SetLastModifiedTimeStr($this->_cPtr,$pathOrHandle,$bIsHandle,$dateTimeStr);
	}

	function SetLastModifiedTimeStrAsync($pathOrHandle,$bIsHandle,$dateTimeStr) {
		$r=CkSFtp_SetLastModifiedTimeStrAsync($this->_cPtr,$pathOrHandle,$bIsHandle,$dateTimeStr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetOwnerAndGroup($pathOrHandle,$isHandle,$owner,$group) {
		return CkSFtp_SetOwnerAndGroup($this->_cPtr,$pathOrHandle,$isHandle,$owner,$group);
	}

	function SetOwnerAndGroupAsync($pathOrHandle,$isHandle,$owner,$group) {
		$r=CkSFtp_SetOwnerAndGroupAsync($this->_cPtr,$pathOrHandle,$isHandle,$owner,$group);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetPermissions($pathOrHandle,$isHandle,$permissions) {
		return CkSFtp_SetPermissions($this->_cPtr,$pathOrHandle,$isHandle,$permissions);
	}

	function SetPermissionsAsync($pathOrHandle,$isHandle,$permissions) {
		$r=CkSFtp_SetPermissionsAsync($this->_cPtr,$pathOrHandle,$isHandle,$permissions);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function startKeyboardAuth($login) {
		return CkSFtp_startKeyboardAuth($this->_cPtr,$login);
	}

	function StartKeyboardAuthAsync($login) {
		$r=CkSFtp_StartKeyboardAuthAsync($this->_cPtr,$login);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SymLink($oldPath,$newPath) {
		return CkSFtp_SymLink($this->_cPtr,$oldPath,$newPath);
	}

	function SymLinkAsync($oldPath,$newPath) {
		$r=CkSFtp_SymLinkAsync($this->_cPtr,$oldPath,$newPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SyncTreeDownload($remoteRoot,$localRoot,$mode,$recurse) {
		return CkSFtp_SyncTreeDownload($this->_cPtr,$remoteRoot,$localRoot,$mode,$recurse);
	}

	function SyncTreeDownloadAsync($remoteRoot,$localRoot,$mode,$recurse) {
		$r=CkSFtp_SyncTreeDownloadAsync($this->_cPtr,$remoteRoot,$localRoot,$mode,$recurse);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SyncTreeUpload($localBaseDir,$remoteBaseDir,$mode,$bRecurse) {
		return CkSFtp_SyncTreeUpload($this->_cPtr,$localBaseDir,$remoteBaseDir,$mode,$bRecurse);
	}

	function SyncTreeUploadAsync($localBaseDir,$remoteBaseDir,$mode,$bRecurse) {
		$r=CkSFtp_SyncTreeUploadAsync($this->_cPtr,$localBaseDir,$remoteBaseDir,$mode,$bRecurse);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UploadBd($binData,$remoteFilePath) {
		return CkSFtp_UploadBd($this->_cPtr,$binData,$remoteFilePath);
	}

	function UploadBdAsync($binData,$remoteFilePath) {
		$r=CkSFtp_UploadBdAsync($this->_cPtr,$binData,$remoteFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UploadFile($handle,$fromLocalFilePath) {
		return CkSFtp_UploadFile($this->_cPtr,$handle,$fromLocalFilePath);
	}

	function UploadFileAsync($handle,$fromLocalFilePath) {
		$r=CkSFtp_UploadFileAsync($this->_cPtr,$handle,$fromLocalFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UploadFileByName($remoteFilePath,$localFilePath) {
		return CkSFtp_UploadFileByName($this->_cPtr,$remoteFilePath,$localFilePath);
	}

	function UploadFileByNameAsync($remoteFilePath,$localFilePath) {
		$r=CkSFtp_UploadFileByNameAsync($this->_cPtr,$remoteFilePath,$localFilePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UploadSb($sb,$remoteFilePath,$charset,$includeBom) {
		return CkSFtp_UploadSb($this->_cPtr,$sb,$remoteFilePath,$charset,$includeBom);
	}

	function UploadSbAsync($sb,$remoteFilePath,$charset,$includeBom) {
		$r=CkSFtp_UploadSbAsync($this->_cPtr,$sb,$remoteFilePath,$charset,$includeBom);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteFileBd($handle,$bd) {
		return CkSFtp_WriteFileBd($this->_cPtr,$handle,$bd);
	}

	function WriteFileBdAsync($handle,$bd) {
		$r=CkSFtp_WriteFileBdAsync($this->_cPtr,$handle,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteFileBytes($handle,$byteData) {
		return CkSFtp_WriteFileBytes($this->_cPtr,$handle,$byteData);
	}

	function WriteFileBytesAsync($handle,$byteData) {
		$r=CkSFtp_WriteFileBytesAsync($this->_cPtr,$handle,$byteData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteFileBytes32($handle,$offset,$data) {
		return CkSFtp_WriteFileBytes32($this->_cPtr,$handle,$offset,$data);
	}

	function WriteFileBytes32Async($handle,$offset,$data) {
		$r=CkSFtp_WriteFileBytes32Async($this->_cPtr,$handle,$offset,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteFileBytes64s($handle,$offset64,$data) {
		return CkSFtp_WriteFileBytes64s($this->_cPtr,$handle,$offset64,$data);
	}

	function WriteFileBytes64sAsync($handle,$offset64,$data) {
		$r=CkSFtp_WriteFileBytes64sAsync($this->_cPtr,$handle,$offset64,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteFileText($handle,$charset,$textData) {
		return CkSFtp_WriteFileText($this->_cPtr,$handle,$charset,$textData);
	}

	function WriteFileTextAsync($handle,$charset,$textData) {
		$r=CkSFtp_WriteFileTextAsync($this->_cPtr,$handle,$charset,$textData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteFileText32($handle,$offset32,$charset,$textData) {
		return CkSFtp_WriteFileText32($this->_cPtr,$handle,$offset32,$charset,$textData);
	}

	function WriteFileText32Async($handle,$offset32,$charset,$textData) {
		$r=CkSFtp_WriteFileText32Async($this->_cPtr,$handle,$offset32,$charset,$textData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteFileText64s($handle,$offset64,$charset,$textData) {
		return CkSFtp_WriteFileText64s($this->_cPtr,$handle,$offset64,$charset,$textData);
	}

	function WriteFileText64sAsync($handle,$offset64,$charset,$textData) {
		$r=CkSFtp_WriteFileText64sAsync($this->_cPtr,$handle,$offset64,$charset,$textData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkSFtpDir {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSFtpDir') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSFtpDir();
	}

	function get_Utf8() {
		return CkSFtpDir_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSFtpDir_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkSFtpDir_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSFtpDir_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSFtpDir_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkSFtpDir_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSFtpDir_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSFtpDir_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSFtpDir_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSFtpDir_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSFtpDir_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSFtpDir_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSFtpDir_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumFilesAndDirs() {
		return CkSFtpDir_get_NumFilesAndDirs($this->_cPtr);
	}

	function get_OriginalPath($str) {
		CkSFtpDir_get_OriginalPath($this->_cPtr,$str);
	}

	function originalPath() {
		return CkSFtpDir_originalPath($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkSFtpDir_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSFtpDir_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSFtpDir_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSFtpDir_version($this->_cPtr);
	}

	function FileAt($index,$fileObj) {
		return CkSFtpDir_FileAt($this->_cPtr,$index,$fileObj);
	}

	function getFilename($index) {
		return CkSFtpDir_getFilename($this->_cPtr,$index);
	}

	function filename($index) {
		return CkSFtpDir_filename($this->_cPtr,$index);
	}

	function GetFileObject($index) {
		$r=CkSFtpDir_GetFileObject($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkSFtpFile($r);
		}
		return $r;
	}

	function LoadTaskResult($task) {
		return CkSFtpDir_LoadTaskResult($this->_cPtr,$task);
	}

	function Sort($field,$ascending) {
		CkSFtpDir_Sort($this->_cPtr,$field,$ascending);
	}
}

class CkSFtpFile {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSFtpFile') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSFtpFile();
	}

	function get_Utf8() {
		return CkSFtpFile_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSFtpFile_put_Utf8($this->_cPtr,$b);
	}

	function get_CreateTimeStr($str) {
		CkSFtpFile_get_CreateTimeStr($this->_cPtr,$str);
	}

	function createTimeStr() {
		return CkSFtpFile_createTimeStr($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkSFtpFile_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSFtpFile_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSFtpFile_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Filename($str) {
		CkSFtpFile_get_Filename($this->_cPtr,$str);
	}

	function filename() {
		return CkSFtpFile_filename($this->_cPtr);
	}

	function get_FileType($str) {
		CkSFtpFile_get_FileType($this->_cPtr,$str);
	}

	function fileType() {
		return CkSFtpFile_fileType($this->_cPtr);
	}

	function get_Gid() {
		return CkSFtpFile_get_Gid($this->_cPtr);
	}

	function get_Group($str) {
		CkSFtpFile_get_Group($this->_cPtr,$str);
	}

	function group() {
		return CkSFtpFile_group($this->_cPtr);
	}

	function get_IsAppendOnly() {
		return CkSFtpFile_get_IsAppendOnly($this->_cPtr);
	}

	function get_IsArchive() {
		return CkSFtpFile_get_IsArchive($this->_cPtr);
	}

	function get_IsCaseInsensitive() {
		return CkSFtpFile_get_IsCaseInsensitive($this->_cPtr);
	}

	function get_IsCompressed() {
		return CkSFtpFile_get_IsCompressed($this->_cPtr);
	}

	function get_IsDirectory() {
		return CkSFtpFile_get_IsDirectory($this->_cPtr);
	}

	function get_IsEncrypted() {
		return CkSFtpFile_get_IsEncrypted($this->_cPtr);
	}

	function get_IsHidden() {
		return CkSFtpFile_get_IsHidden($this->_cPtr);
	}

	function get_IsImmutable() {
		return CkSFtpFile_get_IsImmutable($this->_cPtr);
	}

	function get_IsReadOnly() {
		return CkSFtpFile_get_IsReadOnly($this->_cPtr);
	}

	function get_IsRegular() {
		return CkSFtpFile_get_IsRegular($this->_cPtr);
	}

	function get_IsSparse() {
		return CkSFtpFile_get_IsSparse($this->_cPtr);
	}

	function get_IsSymLink() {
		return CkSFtpFile_get_IsSymLink($this->_cPtr);
	}

	function get_IsSync() {
		return CkSFtpFile_get_IsSync($this->_cPtr);
	}

	function get_IsSystem() {
		return CkSFtpFile_get_IsSystem($this->_cPtr);
	}

	function get_LastAccessTimeStr($str) {
		CkSFtpFile_get_LastAccessTimeStr($this->_cPtr,$str);
	}

	function lastAccessTimeStr() {
		return CkSFtpFile_lastAccessTimeStr($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkSFtpFile_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSFtpFile_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSFtpFile_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSFtpFile_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSFtpFile_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSFtpFile_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSFtpFile_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSFtpFile_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LastModifiedTimeStr($str) {
		CkSFtpFile_get_LastModifiedTimeStr($this->_cPtr,$str);
	}

	function lastModifiedTimeStr() {
		return CkSFtpFile_lastModifiedTimeStr($this->_cPtr);
	}

	function get_Owner($str) {
		CkSFtpFile_get_Owner($this->_cPtr,$str);
	}

	function owner() {
		return CkSFtpFile_owner($this->_cPtr);
	}

	function get_Permissions() {
		return CkSFtpFile_get_Permissions($this->_cPtr);
	}

	function get_Size32() {
		return CkSFtpFile_get_Size32($this->_cPtr);
	}

	function get_Size64() {
		return CkSFtpFile_get_Size64($this->_cPtr);
	}

	function get_SizeStr($str) {
		CkSFtpFile_get_SizeStr($this->_cPtr,$str);
	}

	function sizeStr() {
		return CkSFtpFile_sizeStr($this->_cPtr);
	}

	function get_Uid() {
		return CkSFtpFile_get_Uid($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkSFtpFile_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSFtpFile_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSFtpFile_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSFtpFile_version($this->_cPtr);
	}

	function GetCreateDt() {
		$r=CkSFtpFile_GetCreateDt($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetLastAccessDt() {
		$r=CkSFtpFile_GetLastAccessDt($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetLastModifiedDt() {
		$r=CkSFtpFile_GetLastModifiedDt($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}
}

class CkScMinidriver {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkScMinidriver') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkScMinidriver();
	}

	function get_Utf8() {
		return CkScMinidriver_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkScMinidriver_put_Utf8($this->_cPtr,$b);
	}

	function get_Atr($str) {
		CkScMinidriver_get_Atr($this->_cPtr,$str);
	}

	function atr() {
		return CkScMinidriver_atr($this->_cPtr);
	}

	function get_CardName($str) {
		CkScMinidriver_get_CardName($this->_cPtr,$str);
	}

	function cardName() {
		return CkScMinidriver_cardName($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkScMinidriver_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkScMinidriver_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkScMinidriver_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkScMinidriver_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkScMinidriver_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkScMinidriver_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkScMinidriver_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkScMinidriver_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkScMinidriver_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkScMinidriver_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkScMinidriver_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_MaxContainers() {
		return CkScMinidriver_get_MaxContainers($this->_cPtr);
	}

	function get_RsaPaddingHash($str) {
		CkScMinidriver_get_RsaPaddingHash($this->_cPtr,$str);
	}

	function rsaPaddingHash() {
		return CkScMinidriver_rsaPaddingHash($this->_cPtr);
	}

	function put_RsaPaddingHash($newVal) {
		CkScMinidriver_put_RsaPaddingHash($this->_cPtr,$newVal);
	}

	function get_RsaPaddingScheme($str) {
		CkScMinidriver_get_RsaPaddingScheme($this->_cPtr,$str);
	}

	function rsaPaddingScheme() {
		return CkScMinidriver_rsaPaddingScheme($this->_cPtr);
	}

	function put_RsaPaddingScheme($newVal) {
		CkScMinidriver_put_RsaPaddingScheme($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkScMinidriver_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkScMinidriver_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkScMinidriver_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkScMinidriver_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkScMinidriver_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkScMinidriver_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkScMinidriver_version($this->_cPtr);
	}

	function AcquireContext($readerName) {
		return CkScMinidriver_AcquireContext($this->_cPtr,$readerName);
	}

	function CardDeleteFile($dirName,$fileName) {
		return CkScMinidriver_CardDeleteFile($this->_cPtr,$dirName,$fileName);
	}

	function DeleteCert($cert,$delPrivKey) {
		return CkScMinidriver_DeleteCert($this->_cPtr,$cert,$delPrivKey);
	}

	function DeleteContext() {
		return CkScMinidriver_DeleteContext($this->_cPtr);
	}

	function DeleteKeyContainer($containerIndex) {
		return CkScMinidriver_DeleteKeyContainer($this->_cPtr,$containerIndex);
	}

	function EnumFiles($dirName,$st) {
		return CkScMinidriver_EnumFiles($this->_cPtr,$dirName,$st);
	}

	function FindCert($certPart,$partValue,$cert) {
		return CkScMinidriver_FindCert($this->_cPtr,$certPart,$partValue,$cert);
	}

	function GenerateKey($containerIndex,$keySpec,$keyType,$keySize,$pinId) {
		return CkScMinidriver_GenerateKey($this->_cPtr,$containerIndex,$keySpec,$keyType,$keySize,$pinId);
	}

	function GetCardProperties($json) {
		return CkScMinidriver_GetCardProperties($this->_cPtr,$json);
	}

	function GetCert($containerIndex,$keySpec,$cert) {
		return CkScMinidriver_GetCert($this->_cPtr,$containerIndex,$keySpec,$cert);
	}

	function GetContainerKeys($containerIndex,$sigKey,$kexKey) {
		return CkScMinidriver_GetContainerKeys($this->_cPtr,$containerIndex,$sigKey,$kexKey);
	}

	function GetCspContainerMap($json) {
		return CkScMinidriver_GetCspContainerMap($this->_cPtr,$json);
	}

	function ImportCert($cert,$containerIndex,$keySpec,$pinId) {
		return CkScMinidriver_ImportCert($this->_cPtr,$cert,$containerIndex,$keySpec,$pinId);
	}

	function ImportKey($containerIndex,$keySpec,$privKey,$pinId) {
		return CkScMinidriver_ImportKey($this->_cPtr,$containerIndex,$keySpec,$privKey,$pinId);
	}

	function ListCerts($certPart,$st) {
		return CkScMinidriver_ListCerts($this->_cPtr,$certPart,$st);
	}

	function PinAuthenticate($pinId,$pin) {
		return CkScMinidriver_PinAuthenticate($this->_cPtr,$pinId,$pin);
	}

	function PinAuthenticateHex($pinId,$pin) {
		return CkScMinidriver_PinAuthenticateHex($this->_cPtr,$pinId,$pin);
	}

	function PinChange($pinId,$currentPin,$newPin) {
		return CkScMinidriver_PinChange($this->_cPtr,$pinId,$currentPin,$newPin);
	}

	function PinDeauthenticate($pinId) {
		return CkScMinidriver_PinDeauthenticate($this->_cPtr,$pinId);
	}

	function ReadFile($dirName,$fileName,$bd) {
		return CkScMinidriver_ReadFile($this->_cPtr,$dirName,$fileName,$bd);
	}

	function SignData($containerIndex,$keySpec,$hashDataAlg,$bdData,$bdSignedData) {
		return CkScMinidriver_SignData($this->_cPtr,$containerIndex,$keySpec,$hashDataAlg,$bdData,$bdSignedData);
	}

	function WriteFile($dirName,$fileName,$bd) {
		return CkScMinidriver_WriteFile($this->_cPtr,$dirName,$fileName,$bd);
	}
}

class CkScp {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkScp') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkScp();
	}

	function get_Utf8() {
		return CkScp_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkScp_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkScp_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkScp_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkScp_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkScp_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkScp_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkScp_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkScp_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkScp_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkScp_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkScp_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkScp_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkScp_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkScp_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkScp_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkScp_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkScp_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_PercentDoneScale() {
		return CkScp_get_PercentDoneScale($this->_cPtr);
	}

	function put_PercentDoneScale($newVal) {
		CkScp_put_PercentDoneScale($this->_cPtr,$newVal);
	}

	function get_SendEnv($str) {
		CkScp_get_SendEnv($this->_cPtr,$str);
	}

	function sendEnv() {
		return CkScp_sendEnv($this->_cPtr);
	}

	function put_SendEnv($newVal) {
		CkScp_put_SendEnv($this->_cPtr,$newVal);
	}

	function get_SyncedFiles($str) {
		CkScp_get_SyncedFiles($this->_cPtr,$str);
	}

	function syncedFiles() {
		return CkScp_syncedFiles($this->_cPtr);
	}

	function put_SyncedFiles($newVal) {
		CkScp_put_SyncedFiles($this->_cPtr,$newVal);
	}

	function get_SyncMustMatch($str) {
		CkScp_get_SyncMustMatch($this->_cPtr,$str);
	}

	function syncMustMatch() {
		return CkScp_syncMustMatch($this->_cPtr);
	}

	function put_SyncMustMatch($newVal) {
		CkScp_put_SyncMustMatch($this->_cPtr,$newVal);
	}

	function get_SyncMustMatchDir($str) {
		CkScp_get_SyncMustMatchDir($this->_cPtr,$str);
	}

	function syncMustMatchDir() {
		return CkScp_syncMustMatchDir($this->_cPtr);
	}

	function put_SyncMustMatchDir($newVal) {
		CkScp_put_SyncMustMatchDir($this->_cPtr,$newVal);
	}

	function get_SyncMustNotMatch($str) {
		CkScp_get_SyncMustNotMatch($this->_cPtr,$str);
	}

	function syncMustNotMatch() {
		return CkScp_syncMustNotMatch($this->_cPtr);
	}

	function put_SyncMustNotMatch($newVal) {
		CkScp_put_SyncMustNotMatch($this->_cPtr,$newVal);
	}

	function get_SyncMustNotMatchDir($str) {
		CkScp_get_SyncMustNotMatchDir($this->_cPtr,$str);
	}

	function syncMustNotMatchDir() {
		return CkScp_syncMustNotMatchDir($this->_cPtr);
	}

	function put_SyncMustNotMatchDir($newVal) {
		CkScp_put_SyncMustNotMatchDir($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkScp_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkScp_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkScp_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UnixPermOverride($str) {
		CkScp_get_UnixPermOverride($this->_cPtr,$str);
	}

	function unixPermOverride() {
		return CkScp_unixPermOverride($this->_cPtr);
	}

	function put_UnixPermOverride($newVal) {
		CkScp_put_UnixPermOverride($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkScp_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkScp_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkScp_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkScp_version($this->_cPtr);
	}

	function DownloadBd($remotePath,$bd) {
		return CkScp_DownloadBd($this->_cPtr,$remotePath,$bd);
	}

	function DownloadBdAsync($remotePath,$bd) {
		$r=CkScp_DownloadBdAsync($this->_cPtr,$remotePath,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DownloadBinary($remotePath,$outBytes) {
		return CkScp_DownloadBinary($this->_cPtr,$remotePath,$outBytes);
	}

	function DownloadBinaryAsync($remotePath) {
		$r=CkScp_DownloadBinaryAsync($this->_cPtr,$remotePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function downloadBinaryEncoded($remotePath,$encoding) {
		return CkScp_downloadBinaryEncoded($this->_cPtr,$remotePath,$encoding);
	}

	function DownloadBinaryEncodedAsync($remotePath,$encoding) {
		$r=CkScp_DownloadBinaryEncodedAsync($this->_cPtr,$remotePath,$encoding);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DownloadFile($remotePath,$localPath) {
		return CkScp_DownloadFile($this->_cPtr,$remotePath,$localPath);
	}

	function DownloadFileAsync($remotePath,$localPath) {
		$r=CkScp_DownloadFileAsync($this->_cPtr,$remotePath,$localPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function downloadString($remotePath,$charset) {
		return CkScp_downloadString($this->_cPtr,$remotePath,$charset);
	}

	function DownloadStringAsync($remotePath,$charset) {
		$r=CkScp_DownloadStringAsync($this->_cPtr,$remotePath,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkScp_LoadTaskCaller($this->_cPtr,$task);
	}

	function SyncTreeDownload($remoteRoot,$localRoot,$mode,$bRecurse) {
		return CkScp_SyncTreeDownload($this->_cPtr,$remoteRoot,$localRoot,$mode,$bRecurse);
	}

	function SyncTreeDownloadAsync($remoteRoot,$localRoot,$mode,$bRecurse) {
		$r=CkScp_SyncTreeDownloadAsync($this->_cPtr,$remoteRoot,$localRoot,$mode,$bRecurse);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SyncTreeUpload($localBaseDir,$remoteBaseDir,$mode,$bRecurse) {
		return CkScp_SyncTreeUpload($this->_cPtr,$localBaseDir,$remoteBaseDir,$mode,$bRecurse);
	}

	function SyncTreeUploadAsync($localBaseDir,$remoteBaseDir,$mode,$bRecurse) {
		$r=CkScp_SyncTreeUploadAsync($this->_cPtr,$localBaseDir,$remoteBaseDir,$mode,$bRecurse);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UploadBd($remotePath,$bd) {
		return CkScp_UploadBd($this->_cPtr,$remotePath,$bd);
	}

	function UploadBdAsync($remotePath,$bd) {
		$r=CkScp_UploadBdAsync($this->_cPtr,$remotePath,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UploadBinary($remotePath,$binData) {
		return CkScp_UploadBinary($this->_cPtr,$remotePath,$binData);
	}

	function UploadBinaryAsync($remotePath,$binData) {
		$r=CkScp_UploadBinaryAsync($this->_cPtr,$remotePath,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UploadBinaryEncoded($remotePath,$encodedData,$encoding) {
		return CkScp_UploadBinaryEncoded($this->_cPtr,$remotePath,$encodedData,$encoding);
	}

	function UploadBinaryEncodedAsync($remotePath,$encodedData,$encoding) {
		$r=CkScp_UploadBinaryEncodedAsync($this->_cPtr,$remotePath,$encodedData,$encoding);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UploadFile($localPath,$remotePath) {
		return CkScp_UploadFile($this->_cPtr,$localPath,$remotePath);
	}

	function UploadFileAsync($localPath,$remotePath) {
		$r=CkScp_UploadFileAsync($this->_cPtr,$localPath,$remotePath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UploadString($remotePath,$textData,$charset) {
		return CkScp_UploadString($this->_cPtr,$remotePath,$textData,$charset);
	}

	function UploadStringAsync($remotePath,$textData,$charset) {
		$r=CkScp_UploadStringAsync($this->_cPtr,$remotePath,$textData,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UseSsh($sshConnection) {
		return CkScp_UseSsh($this->_cPtr,$sshConnection);
	}
}

class CkSecrets {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSecrets') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSecrets();
	}

	function get_Utf8() {
		return CkSecrets_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSecrets_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkSecrets_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AutoSplit() {
		return CkSecrets_get_AutoSplit($this->_cPtr);
	}

	function put_AutoSplit($newVal) {
		CkSecrets_put_AutoSplit($this->_cPtr,$newVal);
	}

	function get_Compression() {
		return CkSecrets_get_Compression($this->_cPtr);
	}

	function put_Compression($newVal) {
		CkSecrets_put_Compression($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkSecrets_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSecrets_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSecrets_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkSecrets_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSecrets_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSecrets_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSecrets_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSecrets_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSecrets_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSecrets_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSecrets_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Location($str) {
		CkSecrets_get_Location($this->_cPtr,$str);
	}

	function location() {
		return CkSecrets_location($this->_cPtr);
	}

	function put_Location($newVal) {
		CkSecrets_put_Location($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkSecrets_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkSecrets_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkSecrets_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkSecrets_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSecrets_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSecrets_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSecrets_version($this->_cPtr);
	}

	function DeleteSecret($jsonId) {
		return CkSecrets_DeleteSecret($this->_cPtr,$jsonId);
	}

	function DeleteSecretAsync($jsonId) {
		$r=CkSecrets_DeleteSecretAsync($this->_cPtr,$jsonId);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetSecretBd($jsonId,$bd) {
		return CkSecrets_GetSecretBd($this->_cPtr,$jsonId,$bd);
	}

	function GetSecretBdAsync($jsonId,$bd) {
		$r=CkSecrets_GetSecretBdAsync($this->_cPtr,$jsonId,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetSecretJson($jsonId,$jsonOut) {
		return CkSecrets_GetSecretJson($this->_cPtr,$jsonId,$jsonOut);
	}

	function GetSecretJsonAsync($jsonId,$jsonOut) {
		$r=CkSecrets_GetSecretJsonAsync($this->_cPtr,$jsonId,$jsonOut);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetSecretSb($jsonId,$sb) {
		return CkSecrets_GetSecretSb($this->_cPtr,$jsonId,$sb);
	}

	function GetSecretSbAsync($jsonId,$sb) {
		$r=CkSecrets_GetSecretSbAsync($this->_cPtr,$jsonId,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getSecretStr($jsonId) {
		return CkSecrets_getSecretStr($this->_cPtr,$jsonId);
	}

	function secretStr($jsonId) {
		return CkSecrets_secretStr($this->_cPtr,$jsonId);
	}

	function GetSecretStrAsync($jsonId) {
		$r=CkSecrets_GetSecretStrAsync($this->_cPtr,$jsonId);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ListSecrets($json,$jsonOut) {
		return CkSecrets_ListSecrets($this->_cPtr,$json,$jsonOut);
	}

	function ListSecretsAsync($json,$jsonOut) {
		$r=CkSecrets_ListSecretsAsync($this->_cPtr,$json,$jsonOut);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetBootstrapSecret($jsonId,$secretContent) {
		return CkSecrets_SetBootstrapSecret($this->_cPtr,$jsonId,$secretContent);
	}

	function UpdateSecretBd($jsonId,$secret) {
		return CkSecrets_UpdateSecretBd($this->_cPtr,$jsonId,$secret);
	}

	function UpdateSecretBdAsync($jsonId,$secret) {
		$r=CkSecrets_UpdateSecretBdAsync($this->_cPtr,$jsonId,$secret);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UpdateSecretJson($jsonId,$secret) {
		return CkSecrets_UpdateSecretJson($this->_cPtr,$jsonId,$secret);
	}

	function UpdateSecretJsonAsync($jsonId,$secret) {
		$r=CkSecrets_UpdateSecretJsonAsync($this->_cPtr,$jsonId,$secret);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UpdateSecretSb($jsonId,$sb) {
		return CkSecrets_UpdateSecretSb($this->_cPtr,$jsonId,$sb);
	}

	function UpdateSecretSbAsync($jsonId,$sb) {
		$r=CkSecrets_UpdateSecretSbAsync($this->_cPtr,$jsonId,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UpdateSecretStr($jsonId,$secret) {
		return CkSecrets_UpdateSecretStr($this->_cPtr,$jsonId,$secret);
	}

	function UpdateSecretStrAsync($jsonId,$secret) {
		$r=CkSecrets_UpdateSecretStrAsync($this->_cPtr,$jsonId,$secret);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkSecureString {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSecureString') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSecureString();
	}

	function get_Utf8() {
		return CkSecureString_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSecureString_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkSecureString_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSecureString_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSecureString_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkSecureString_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSecureString_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSecureString_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSecureString_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSecureString_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSecureString_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSecureString_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSecureString_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_MaintainHash($str) {
		CkSecureString_get_MaintainHash($this->_cPtr,$str);
	}

	function maintainHash() {
		return CkSecureString_maintainHash($this->_cPtr);
	}

	function put_MaintainHash($newVal) {
		CkSecureString_put_MaintainHash($this->_cPtr,$newVal);
	}

	function get_ReadOnly() {
		return CkSecureString_get_ReadOnly($this->_cPtr);
	}

	function put_ReadOnly($newVal) {
		CkSecureString_put_ReadOnly($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkSecureString_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSecureString_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSecureString_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSecureString_version($this->_cPtr);
	}

	function access() {
		return CkSecureString_access($this->_cPtr);
	}

	function Append($str) {
		return CkSecureString_Append($this->_cPtr,$str);
	}

	function AppendSb($sb) {
		return CkSecureString_AppendSb($this->_cPtr,$sb);
	}

	function AppendSecure($secStr) {
		return CkSecureString_AppendSecure($this->_cPtr,$secStr);
	}

	function hashVal($encoding) {
		return CkSecureString_hashVal($this->_cPtr,$encoding);
	}

	function LoadFile($path,$charset) {
		return CkSecureString_LoadFile($this->_cPtr,$path,$charset);
	}

	function SecStrEquals($secStr) {
		return CkSecureString_SecStrEquals($this->_cPtr,$secStr);
	}

	function VerifyHash($hashVal,$encoding) {
		return CkSecureString_VerifyHash($this->_cPtr,$hashVal,$encoding);
	}
}

class CkServerSentEvent {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkServerSentEvent') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkServerSentEvent();
	}

	function get_Utf8() {
		return CkServerSentEvent_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkServerSentEvent_put_Utf8($this->_cPtr,$b);
	}

	function get_Data($str) {
		CkServerSentEvent_get_Data($this->_cPtr,$str);
	}

	function data() {
		return CkServerSentEvent_data($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkServerSentEvent_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkServerSentEvent_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkServerSentEvent_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EventName($str) {
		CkServerSentEvent_get_EventName($this->_cPtr,$str);
	}

	function eventName() {
		return CkServerSentEvent_eventName($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkServerSentEvent_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkServerSentEvent_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkServerSentEvent_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkServerSentEvent_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkServerSentEvent_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkServerSentEvent_lastErrorXml($this->_cPtr);
	}

	function get_LastEventId($str) {
		CkServerSentEvent_get_LastEventId($this->_cPtr,$str);
	}

	function lastEventId() {
		return CkServerSentEvent_lastEventId($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkServerSentEvent_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkServerSentEvent_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Retry() {
		return CkServerSentEvent_get_Retry($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkServerSentEvent_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkServerSentEvent_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkServerSentEvent_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkServerSentEvent_version($this->_cPtr);
	}

	function LoadEvent($eventText) {
		return CkServerSentEvent_LoadEvent($this->_cPtr,$eventText);
	}
}

class CkSocket {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSocket') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSocket();
	}

	function get_Utf8() {
		return CkSocket_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSocket_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkSocket_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkSocket_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkSocket_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_AcceptFailReason() {
		return CkSocket_get_AcceptFailReason($this->_cPtr);
	}

	function get_AlpnProtocol($str) {
		CkSocket_get_AlpnProtocol($this->_cPtr,$str);
	}

	function alpnProtocol() {
		return CkSocket_alpnProtocol($this->_cPtr);
	}

	function put_AlpnProtocol($newVal) {
		CkSocket_put_AlpnProtocol($this->_cPtr,$newVal);
	}

	function get_BandwidthThrottleDown() {
		return CkSocket_get_BandwidthThrottleDown($this->_cPtr);
	}

	function put_BandwidthThrottleDown($newVal) {
		CkSocket_put_BandwidthThrottleDown($this->_cPtr,$newVal);
	}

	function get_BandwidthThrottleUp() {
		return CkSocket_get_BandwidthThrottleUp($this->_cPtr);
	}

	function put_BandwidthThrottleUp($newVal) {
		CkSocket_put_BandwidthThrottleUp($this->_cPtr,$newVal);
	}

	function get_BigEndian() {
		return CkSocket_get_BigEndian($this->_cPtr);
	}

	function put_BigEndian($newVal) {
		CkSocket_put_BigEndian($this->_cPtr,$newVal);
	}

	function get_ClientIpAddress($str) {
		CkSocket_get_ClientIpAddress($this->_cPtr,$str);
	}

	function clientIpAddress() {
		return CkSocket_clientIpAddress($this->_cPtr);
	}

	function put_ClientIpAddress($newVal) {
		CkSocket_put_ClientIpAddress($this->_cPtr,$newVal);
	}

	function get_ClientPort() {
		return CkSocket_get_ClientPort($this->_cPtr);
	}

	function put_ClientPort($newVal) {
		CkSocket_put_ClientPort($this->_cPtr,$newVal);
	}

	function get_ConnectFailReason() {
		return CkSocket_get_ConnectFailReason($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkSocket_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSocket_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSocket_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_ElapsedSeconds() {
		return CkSocket_get_ElapsedSeconds($this->_cPtr);
	}

	function get_HeartbeatMs() {
		return CkSocket_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkSocket_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_HttpProxyAuthMethod($str) {
		CkSocket_get_HttpProxyAuthMethod($this->_cPtr,$str);
	}

	function httpProxyAuthMethod() {
		return CkSocket_httpProxyAuthMethod($this->_cPtr);
	}

	function put_HttpProxyAuthMethod($newVal) {
		CkSocket_put_HttpProxyAuthMethod($this->_cPtr,$newVal);
	}

	function get_HttpProxyDomain($str) {
		CkSocket_get_HttpProxyDomain($this->_cPtr,$str);
	}

	function httpProxyDomain() {
		return CkSocket_httpProxyDomain($this->_cPtr);
	}

	function put_HttpProxyDomain($newVal) {
		CkSocket_put_HttpProxyDomain($this->_cPtr,$newVal);
	}

	function get_HttpProxyForHttp() {
		return CkSocket_get_HttpProxyForHttp($this->_cPtr);
	}

	function put_HttpProxyForHttp($newVal) {
		CkSocket_put_HttpProxyForHttp($this->_cPtr,$newVal);
	}

	function get_HttpProxyHostname($str) {
		CkSocket_get_HttpProxyHostname($this->_cPtr,$str);
	}

	function httpProxyHostname() {
		return CkSocket_httpProxyHostname($this->_cPtr);
	}

	function put_HttpProxyHostname($newVal) {
		CkSocket_put_HttpProxyHostname($this->_cPtr,$newVal);
	}

	function get_HttpProxyPassword($str) {
		CkSocket_get_HttpProxyPassword($this->_cPtr,$str);
	}

	function httpProxyPassword() {
		return CkSocket_httpProxyPassword($this->_cPtr);
	}

	function put_HttpProxyPassword($newVal) {
		CkSocket_put_HttpProxyPassword($this->_cPtr,$newVal);
	}

	function get_HttpProxyPort() {
		return CkSocket_get_HttpProxyPort($this->_cPtr);
	}

	function put_HttpProxyPort($newVal) {
		CkSocket_put_HttpProxyPort($this->_cPtr,$newVal);
	}

	function get_HttpProxyUsername($str) {
		CkSocket_get_HttpProxyUsername($this->_cPtr,$str);
	}

	function httpProxyUsername() {
		return CkSocket_httpProxyUsername($this->_cPtr);
	}

	function put_HttpProxyUsername($newVal) {
		CkSocket_put_HttpProxyUsername($this->_cPtr,$newVal);
	}

	function get_IsConnected() {
		return CkSocket_get_IsConnected($this->_cPtr);
	}

	function get_KeepAlive() {
		return CkSocket_get_KeepAlive($this->_cPtr);
	}

	function put_KeepAlive($newVal) {
		CkSocket_put_KeepAlive($this->_cPtr,$newVal);
	}

	function get_KeepSessionLog() {
		return CkSocket_get_KeepSessionLog($this->_cPtr);
	}

	function put_KeepSessionLog($newVal) {
		CkSocket_put_KeepSessionLog($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkSocket_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSocket_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSocket_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSocket_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSocket_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSocket_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodFailed() {
		return CkSocket_get_LastMethodFailed($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSocket_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSocket_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_ListenIpv6() {
		return CkSocket_get_ListenIpv6($this->_cPtr);
	}

	function put_ListenIpv6($newVal) {
		CkSocket_put_ListenIpv6($this->_cPtr,$newVal);
	}

	function get_ListenPort() {
		return CkSocket_get_ListenPort($this->_cPtr);
	}

	function get_LocalIpAddress($str) {
		CkSocket_get_LocalIpAddress($this->_cPtr,$str);
	}

	function localIpAddress() {
		return CkSocket_localIpAddress($this->_cPtr);
	}

	function get_LocalPort() {
		return CkSocket_get_LocalPort($this->_cPtr);
	}

	function get_MaxReadIdleMs() {
		return CkSocket_get_MaxReadIdleMs($this->_cPtr);
	}

	function put_MaxReadIdleMs($newVal) {
		CkSocket_put_MaxReadIdleMs($this->_cPtr,$newVal);
	}

	function get_MaxSendIdleMs() {
		return CkSocket_get_MaxSendIdleMs($this->_cPtr);
	}

	function put_MaxSendIdleMs($newVal) {
		CkSocket_put_MaxSendIdleMs($this->_cPtr,$newVal);
	}

	function get_MyIpAddress($str) {
		CkSocket_get_MyIpAddress($this->_cPtr,$str);
	}

	function myIpAddress() {
		return CkSocket_myIpAddress($this->_cPtr);
	}

	function get_NumBytesAvailable() {
		return CkSocket_get_NumBytesAvailable($this->_cPtr);
	}

	function get_NumReceivedClientCerts() {
		return CkSocket_get_NumReceivedClientCerts($this->_cPtr);
	}

	function get_NumSocketsInSet() {
		return CkSocket_get_NumSocketsInSet($this->_cPtr);
	}

	function get_NumSslAcceptableClientCAs() {
		return CkSocket_get_NumSslAcceptableClientCAs($this->_cPtr);
	}

	function get_ObjectId() {
		return CkSocket_get_ObjectId($this->_cPtr);
	}

	function get_PercentDoneScale() {
		return CkSocket_get_PercentDoneScale($this->_cPtr);
	}

	function put_PercentDoneScale($newVal) {
		CkSocket_put_PercentDoneScale($this->_cPtr,$newVal);
	}

	function get_PreferIpv6() {
		return CkSocket_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkSocket_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_RcvBytesPerSec() {
		return CkSocket_get_RcvBytesPerSec($this->_cPtr);
	}

	function get_ReceivedCount() {
		return CkSocket_get_ReceivedCount($this->_cPtr);
	}

	function put_ReceivedCount($newVal) {
		CkSocket_put_ReceivedCount($this->_cPtr,$newVal);
	}

	function get_ReceivedInt() {
		return CkSocket_get_ReceivedInt($this->_cPtr);
	}

	function put_ReceivedInt($newVal) {
		CkSocket_put_ReceivedInt($this->_cPtr,$newVal);
	}

	function get_ReceiveFailReason() {
		return CkSocket_get_ReceiveFailReason($this->_cPtr);
	}

	function get_ReceivePacketSize() {
		return CkSocket_get_ReceivePacketSize($this->_cPtr);
	}

	function put_ReceivePacketSize($newVal) {
		CkSocket_put_ReceivePacketSize($this->_cPtr,$newVal);
	}

	function get_RemoteIpAddress($str) {
		CkSocket_get_RemoteIpAddress($this->_cPtr,$str);
	}

	function remoteIpAddress() {
		return CkSocket_remoteIpAddress($this->_cPtr);
	}

	function get_RemotePort() {
		return CkSocket_get_RemotePort($this->_cPtr);
	}

	function get_RequireSslCertVerify() {
		return CkSocket_get_RequireSslCertVerify($this->_cPtr);
	}

	function put_RequireSslCertVerify($newVal) {
		CkSocket_put_RequireSslCertVerify($this->_cPtr,$newVal);
	}

	function get_SelectorIndex() {
		return CkSocket_get_SelectorIndex($this->_cPtr);
	}

	function put_SelectorIndex($newVal) {
		CkSocket_put_SelectorIndex($this->_cPtr,$newVal);
	}

	function get_SelectorReadIndex() {
		return CkSocket_get_SelectorReadIndex($this->_cPtr);
	}

	function put_SelectorReadIndex($newVal) {
		CkSocket_put_SelectorReadIndex($this->_cPtr,$newVal);
	}

	function get_SelectorWriteIndex() {
		return CkSocket_get_SelectorWriteIndex($this->_cPtr);
	}

	function put_SelectorWriteIndex($newVal) {
		CkSocket_put_SelectorWriteIndex($this->_cPtr,$newVal);
	}

	function get_SendBytesPerSec() {
		return CkSocket_get_SendBytesPerSec($this->_cPtr);
	}

	function get_SendFailReason() {
		return CkSocket_get_SendFailReason($this->_cPtr);
	}

	function get_SendPacketSize() {
		return CkSocket_get_SendPacketSize($this->_cPtr);
	}

	function put_SendPacketSize($newVal) {
		CkSocket_put_SendPacketSize($this->_cPtr,$newVal);
	}

	function get_SessionLog($str) {
		CkSocket_get_SessionLog($this->_cPtr,$str);
	}

	function sessionLog() {
		return CkSocket_sessionLog($this->_cPtr);
	}

	function get_SessionLogEncoding($str) {
		CkSocket_get_SessionLogEncoding($this->_cPtr,$str);
	}

	function sessionLogEncoding() {
		return CkSocket_sessionLogEncoding($this->_cPtr);
	}

	function put_SessionLogEncoding($newVal) {
		CkSocket_put_SessionLogEncoding($this->_cPtr,$newVal);
	}

	function get_SniHostname($str) {
		CkSocket_get_SniHostname($this->_cPtr,$str);
	}

	function sniHostname() {
		return CkSocket_sniHostname($this->_cPtr);
	}

	function put_SniHostname($newVal) {
		CkSocket_put_SniHostname($this->_cPtr,$newVal);
	}

	function get_SocksHostname($str) {
		CkSocket_get_SocksHostname($this->_cPtr,$str);
	}

	function socksHostname() {
		return CkSocket_socksHostname($this->_cPtr);
	}

	function put_SocksHostname($newVal) {
		CkSocket_put_SocksHostname($this->_cPtr,$newVal);
	}

	function get_SocksPassword($str) {
		CkSocket_get_SocksPassword($this->_cPtr,$str);
	}

	function socksPassword() {
		return CkSocket_socksPassword($this->_cPtr);
	}

	function put_SocksPassword($newVal) {
		CkSocket_put_SocksPassword($this->_cPtr,$newVal);
	}

	function get_SocksPort() {
		return CkSocket_get_SocksPort($this->_cPtr);
	}

	function put_SocksPort($newVal) {
		CkSocket_put_SocksPort($this->_cPtr,$newVal);
	}

	function get_SocksUsername($str) {
		CkSocket_get_SocksUsername($this->_cPtr,$str);
	}

	function socksUsername() {
		return CkSocket_socksUsername($this->_cPtr);
	}

	function put_SocksUsername($newVal) {
		CkSocket_put_SocksUsername($this->_cPtr,$newVal);
	}

	function get_SocksVersion() {
		return CkSocket_get_SocksVersion($this->_cPtr);
	}

	function put_SocksVersion($newVal) {
		CkSocket_put_SocksVersion($this->_cPtr,$newVal);
	}

	function get_SoRcvBuf() {
		return CkSocket_get_SoRcvBuf($this->_cPtr);
	}

	function put_SoRcvBuf($newVal) {
		CkSocket_put_SoRcvBuf($this->_cPtr,$newVal);
	}

	function get_SoReuseAddr() {
		return CkSocket_get_SoReuseAddr($this->_cPtr);
	}

	function put_SoReuseAddr($newVal) {
		CkSocket_put_SoReuseAddr($this->_cPtr,$newVal);
	}

	function get_SoSndBuf() {
		return CkSocket_get_SoSndBuf($this->_cPtr);
	}

	function put_SoSndBuf($newVal) {
		CkSocket_put_SoSndBuf($this->_cPtr,$newVal);
	}

	function get_Ssl() {
		return CkSocket_get_Ssl($this->_cPtr);
	}

	function put_Ssl($newVal) {
		CkSocket_put_Ssl($this->_cPtr,$newVal);
	}

	function get_SslAllowedCiphers($str) {
		CkSocket_get_SslAllowedCiphers($this->_cPtr,$str);
	}

	function sslAllowedCiphers() {
		return CkSocket_sslAllowedCiphers($this->_cPtr);
	}

	function put_SslAllowedCiphers($newVal) {
		CkSocket_put_SslAllowedCiphers($this->_cPtr,$newVal);
	}

	function get_SslProtocol($str) {
		CkSocket_get_SslProtocol($this->_cPtr,$str);
	}

	function sslProtocol() {
		return CkSocket_sslProtocol($this->_cPtr);
	}

	function put_SslProtocol($newVal) {
		CkSocket_put_SslProtocol($this->_cPtr,$newVal);
	}

	function get_StringCharset($str) {
		CkSocket_get_StringCharset($this->_cPtr,$str);
	}

	function stringCharset() {
		return CkSocket_stringCharset($this->_cPtr);
	}

	function put_StringCharset($newVal) {
		CkSocket_put_StringCharset($this->_cPtr,$newVal);
	}

	function get_TcpNoDelay() {
		return CkSocket_get_TcpNoDelay($this->_cPtr);
	}

	function put_TcpNoDelay($newVal) {
		CkSocket_put_TcpNoDelay($this->_cPtr,$newVal);
	}

	function get_TlsCipherSuite($str) {
		CkSocket_get_TlsCipherSuite($this->_cPtr,$str);
	}

	function tlsCipherSuite() {
		return CkSocket_tlsCipherSuite($this->_cPtr);
	}

	function get_TlsPinSet($str) {
		CkSocket_get_TlsPinSet($this->_cPtr,$str);
	}

	function tlsPinSet() {
		return CkSocket_tlsPinSet($this->_cPtr);
	}

	function put_TlsPinSet($newVal) {
		CkSocket_put_TlsPinSet($this->_cPtr,$newVal);
	}

	function get_TlsVersion($str) {
		CkSocket_get_TlsVersion($this->_cPtr,$str);
	}

	function tlsVersion() {
		return CkSocket_tlsVersion($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkSocket_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkSocket_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkSocket_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UserData($str) {
		CkSocket_get_UserData($this->_cPtr,$str);
	}

	function userData() {
		return CkSocket_userData($this->_cPtr);
	}

	function put_UserData($newVal) {
		CkSocket_put_UserData($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkSocket_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSocket_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSocket_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSocket_version($this->_cPtr);
	}

	function AcceptNext($maxWaitMs,$socket) {
		return CkSocket_AcceptNext($this->_cPtr,$maxWaitMs,$socket);
	}

	function AcceptNextAsync($maxWaitMs,$socket) {
		$r=CkSocket_AcceptNextAsync($this->_cPtr,$maxWaitMs,$socket);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AcceptNextConnection($maxWaitMs) {
		$r=CkSocket_AcceptNextConnection($this->_cPtr,$maxWaitMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkSocket($r);
		}
		return $r;
	}

	function AcceptNextConnectionAsync($maxWaitMs) {
		$r=CkSocket_AcceptNextConnectionAsync($this->_cPtr,$maxWaitMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AddSslAcceptableClientCaDn($certAuthDN) {
		return CkSocket_AddSslAcceptableClientCaDn($this->_cPtr,$certAuthDN);
	}

	function BindAndListen($port,$backLog) {
		return CkSocket_BindAndListen($this->_cPtr,$port,$backLog);
	}

	function BindAndListenAsync($port,$backLog) {
		$r=CkSocket_BindAndListenAsync($this->_cPtr,$port,$backLog);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function BindAndListenPortRange($beginPort,$endPort,$backLog) {
		return CkSocket_BindAndListenPortRange($this->_cPtr,$beginPort,$endPort,$backLog);
	}

	function BindAndListenPortRangeAsync($beginPort,$endPort,$backLog) {
		$r=CkSocket_BindAndListenPortRangeAsync($this->_cPtr,$beginPort,$endPort,$backLog);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function buildHttpGetRequest($url) {
		return CkSocket_buildHttpGetRequest($this->_cPtr,$url);
	}

	function CheckWriteable($maxWaitMs) {
		return CkSocket_CheckWriteable($this->_cPtr,$maxWaitMs);
	}

	function CheckWriteableAsync($maxWaitMs) {
		$r=CkSocket_CheckWriteableAsync($this->_cPtr,$maxWaitMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ClearSessionLog() {
		CkSocket_ClearSessionLog($this->_cPtr);
	}

	function CloneSocket() {
		$r=CkSocket_CloneSocket($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkSocket($r);
		}
		return $r;
	}

	function Close($maxWaitMs) {
		return CkSocket_Close($this->_cPtr,$maxWaitMs);
	}

	function CloseAsync($maxWaitMs) {
		$r=CkSocket_CloseAsync($this->_cPtr,$maxWaitMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Connect($hostname,$port,$ssl,$maxWaitMs) {
		return CkSocket_Connect($this->_cPtr,$hostname,$port,$ssl,$maxWaitMs);
	}

	function ConnectAsync($hostname,$port,$ssl,$maxWaitMs) {
		$r=CkSocket_ConnectAsync($this->_cPtr,$hostname,$port,$ssl,$maxWaitMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ConvertFromSsl() {
		return CkSocket_ConvertFromSsl($this->_cPtr);
	}

	function ConvertFromSslAsync() {
		$r=CkSocket_ConvertFromSslAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ConvertToSsl() {
		return CkSocket_ConvertToSsl($this->_cPtr);
	}

	function ConvertToSslAsync() {
		$r=CkSocket_ConvertToSslAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DnsCacheClear() {
		CkSocket_DnsCacheClear($this->_cPtr);
	}

	function dnsLookup($hostname,$maxWaitMs) {
		return CkSocket_dnsLookup($this->_cPtr,$hostname,$maxWaitMs);
	}

	function DnsLookupAsync($hostname,$maxWaitMs) {
		$r=CkSocket_DnsLookupAsync($this->_cPtr,$hostname,$maxWaitMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DupSocket($dest) {
		return CkSocket_DupSocket($this->_cPtr,$dest);
	}

	function GetAdaptersAddresses($json) {
		return CkSocket_GetAdaptersAddresses($this->_cPtr,$json);
	}

	function GetLastJsonData($json) {
		CkSocket_GetLastJsonData($this->_cPtr,$json);
	}

	function GetMyCert() {
		$r=CkSocket_GetMyCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetMyServerCert($cert) {
		return CkSocket_GetMyServerCert($this->_cPtr,$cert);
	}

	function GetRcvdClientCert($index,$cert) {
		return CkSocket_GetRcvdClientCert($this->_cPtr,$index,$cert);
	}

	function GetReceivedClientCert($index) {
		$r=CkSocket_GetReceivedClientCert($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function GetServerCert($cert) {
		return CkSocket_GetServerCert($this->_cPtr,$cert);
	}

	function getSslAcceptableClientCaDn($index) {
		return CkSocket_getSslAcceptableClientCaDn($this->_cPtr,$index);
	}

	function sslAcceptableClientCaDn($index) {
		return CkSocket_sslAcceptableClientCaDn($this->_cPtr,$index);
	}

	function GetSslServerCert() {
		$r=CkSocket_GetSslServerCert($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function InitSslServer($cert) {
		return CkSocket_InitSslServer($this->_cPtr,$cert);
	}

	function LastJsonData() {
		$r=CkSocket_LastJsonData($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkSocket_LoadTaskCaller($this->_cPtr,$task);
	}

	function LoadTaskResult($task) {
		return CkSocket_LoadTaskResult($this->_cPtr,$task);
	}

	function PollDataAvailable() {
		return CkSocket_PollDataAvailable($this->_cPtr);
	}

	function PollDataAvailableAsync() {
		$r=CkSocket_PollDataAvailableAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveBd($binData) {
		return CkSocket_ReceiveBd($this->_cPtr,$binData);
	}

	function ReceiveBdAsync($binData) {
		$r=CkSocket_ReceiveBdAsync($this->_cPtr,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveBdN($numBytes,$binData) {
		return CkSocket_ReceiveBdN($this->_cPtr,$numBytes,$binData);
	}

	function ReceiveBdNAsync($numBytes,$binData) {
		$r=CkSocket_ReceiveBdNAsync($this->_cPtr,$numBytes,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveByte($bUnsigned) {
		return CkSocket_ReceiveByte($this->_cPtr,$bUnsigned);
	}

	function ReceiveByteAsync($bUnsigned) {
		$r=CkSocket_ReceiveByteAsync($this->_cPtr,$bUnsigned);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveBytes($outData) {
		return CkSocket_ReceiveBytes($this->_cPtr,$outData);
	}

	function ReceiveBytesAsync() {
		$r=CkSocket_ReceiveBytesAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function receiveBytesENC($encodingAlg) {
		return CkSocket_receiveBytesENC($this->_cPtr,$encodingAlg);
	}

	function ReceiveBytesENCAsync($encodingAlg) {
		$r=CkSocket_ReceiveBytesENCAsync($this->_cPtr,$encodingAlg);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveBytesN($numBytes,$outData) {
		return CkSocket_ReceiveBytesN($this->_cPtr,$numBytes,$outData);
	}

	function ReceiveBytesNAsync($numBytes) {
		$r=CkSocket_ReceiveBytesNAsync($this->_cPtr,$numBytes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveBytesToFile($appendFilename) {
		return CkSocket_ReceiveBytesToFile($this->_cPtr,$appendFilename);
	}

	function ReceiveBytesToFileAsync($appendFilename) {
		$r=CkSocket_ReceiveBytesToFileAsync($this->_cPtr,$appendFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveCount() {
		return CkSocket_ReceiveCount($this->_cPtr);
	}

	function ReceiveCountAsync() {
		$r=CkSocket_ReceiveCountAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveInt16($bigEndian,$bUnsigned) {
		return CkSocket_ReceiveInt16($this->_cPtr,$bigEndian,$bUnsigned);
	}

	function ReceiveInt16Async($bigEndian,$bUnsigned) {
		$r=CkSocket_ReceiveInt16Async($this->_cPtr,$bigEndian,$bUnsigned);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveInt32($bigEndian) {
		return CkSocket_ReceiveInt32($this->_cPtr,$bigEndian);
	}

	function ReceiveInt32Async($bigEndian) {
		$r=CkSocket_ReceiveInt32Async($this->_cPtr,$bigEndian);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function receiveNBytesENC($numBytes,$encodingAlg) {
		return CkSocket_receiveNBytesENC($this->_cPtr,$numBytes,$encodingAlg);
	}

	function ReceiveNBytesENCAsync($numBytes,$encodingAlg) {
		$r=CkSocket_ReceiveNBytesENCAsync($this->_cPtr,$numBytes,$encodingAlg);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveSb($sb) {
		return CkSocket_ReceiveSb($this->_cPtr,$sb);
	}

	function ReceiveSbAsync($sb) {
		$r=CkSocket_ReceiveSbAsync($this->_cPtr,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function receiveString() {
		return CkSocket_receiveString($this->_cPtr);
	}

	function ReceiveStringAsync() {
		$r=CkSocket_ReceiveStringAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function receiveStringMaxN($maxByteCount) {
		return CkSocket_receiveStringMaxN($this->_cPtr,$maxByteCount);
	}

	function ReceiveStringMaxNAsync($maxByteCount) {
		$r=CkSocket_ReceiveStringMaxNAsync($this->_cPtr,$maxByteCount);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function receiveStringUntilByte($lookForByte) {
		return CkSocket_receiveStringUntilByte($this->_cPtr,$lookForByte);
	}

	function ReceiveStringUntilByteAsync($lookForByte) {
		$r=CkSocket_ReceiveStringUntilByteAsync($this->_cPtr,$lookForByte);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function receiveToCRLF() {
		return CkSocket_receiveToCRLF($this->_cPtr);
	}

	function ReceiveToCRLFAsync() {
		$r=CkSocket_ReceiveToCRLFAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveUntilByte($lookForByte,$outBytes) {
		return CkSocket_ReceiveUntilByte($this->_cPtr,$lookForByte,$outBytes);
	}

	function ReceiveUntilByteAsync($lookForByte) {
		$r=CkSocket_ReceiveUntilByteAsync($this->_cPtr,$lookForByte);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveUntilByteBd($lookForByte,$bd) {
		return CkSocket_ReceiveUntilByteBd($this->_cPtr,$lookForByte,$bd);
	}

	function ReceiveUntilByteBdAsync($lookForByte,$bd) {
		$r=CkSocket_ReceiveUntilByteBdAsync($this->_cPtr,$lookForByte,$bd);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function receiveUntilMatch($matchStr) {
		return CkSocket_receiveUntilMatch($this->_cPtr,$matchStr);
	}

	function ReceiveUntilMatchAsync($matchStr) {
		$r=CkSocket_ReceiveUntilMatchAsync($this->_cPtr,$matchStr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReceiveUntilMatchSb($matchStr,$sb) {
		return CkSocket_ReceiveUntilMatchSb($this->_cPtr,$matchStr,$sb);
	}

	function ReceiveUntilMatchSbAsync($matchStr,$sb) {
		$r=CkSocket_ReceiveUntilMatchSbAsync($this->_cPtr,$matchStr,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ResetPerf($rcvPerf) {
		CkSocket_ResetPerf($this->_cPtr,$rcvPerf);
	}

	function SelectForReading($timeoutMs) {
		return CkSocket_SelectForReading($this->_cPtr,$timeoutMs);
	}

	function SelectForReadingAsync($timeoutMs) {
		$r=CkSocket_SelectForReadingAsync($this->_cPtr,$timeoutMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SelectForWriting($timeoutMs) {
		return CkSocket_SelectForWriting($this->_cPtr,$timeoutMs);
	}

	function SelectForWritingAsync($timeoutMs) {
		$r=CkSocket_SelectForWritingAsync($this->_cPtr,$timeoutMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendBd($binData,$offset,$numBytes) {
		return CkSocket_SendBd($this->_cPtr,$binData,$offset,$numBytes);
	}

	function SendBdAsync($binData,$offset,$numBytes) {
		$r=CkSocket_SendBdAsync($this->_cPtr,$binData,$offset,$numBytes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendByte($value) {
		return CkSocket_SendByte($this->_cPtr,$value);
	}

	function SendByteAsync($value) {
		$r=CkSocket_SendByteAsync($this->_cPtr,$value);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendBytes($data) {
		return CkSocket_SendBytes($this->_cPtr,$data);
	}

	function SendBytesAsync($data) {
		$r=CkSocket_SendBytesAsync($this->_cPtr,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendBytesENC($encodedBytes,$encodingAlg) {
		return CkSocket_SendBytesENC($this->_cPtr,$encodedBytes,$encodingAlg);
	}

	function SendBytesENCAsync($encodedBytes,$encodingAlg) {
		$r=CkSocket_SendBytesENCAsync($this->_cPtr,$encodedBytes,$encodingAlg);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendCount($byteCount) {
		return CkSocket_SendCount($this->_cPtr,$byteCount);
	}

	function SendCountAsync($byteCount) {
		$r=CkSocket_SendCountAsync($this->_cPtr,$byteCount);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendInt16($value,$bigEndian) {
		return CkSocket_SendInt16($this->_cPtr,$value,$bigEndian);
	}

	function SendInt16Async($value,$bigEndian) {
		$r=CkSocket_SendInt16Async($this->_cPtr,$value,$bigEndian);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendInt32($value,$bigEndian) {
		return CkSocket_SendInt32($this->_cPtr,$value,$bigEndian);
	}

	function SendInt32Async($value,$bigEndian) {
		$r=CkSocket_SendInt32Async($this->_cPtr,$value,$bigEndian);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendSb($sb) {
		return CkSocket_SendSb($this->_cPtr,$sb);
	}

	function SendSbAsync($sb) {
		$r=CkSocket_SendSbAsync($this->_cPtr,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendString($stringToSend) {
		return CkSocket_SendString($this->_cPtr,$stringToSend);
	}

	function SendStringAsync($stringToSend) {
		$r=CkSocket_SendStringAsync($this->_cPtr,$stringToSend);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendWakeOnLan($macAddress,$port,$ipBroadcastAddr) {
		return CkSocket_SendWakeOnLan($this->_cPtr,$macAddress,$port,$ipBroadcastAddr);
	}

	function SendWakeOnLan2($macAddress,$port,$ipBroadcastAddr,$password) {
		return CkSocket_SendWakeOnLan2($this->_cPtr,$macAddress,$port,$ipBroadcastAddr,$password);
	}

	function SetSslClientCert($cert) {
		return CkSocket_SetSslClientCert($this->_cPtr,$cert);
	}

	function SetSslClientCertPem($pemDataOrFilename,$pemPassword) {
		return CkSocket_SetSslClientCertPem($this->_cPtr,$pemDataOrFilename,$pemPassword);
	}

	function SetSslClientCertPfx($pfxFilename,$pfxPassword) {
		return CkSocket_SetSslClientCertPfx($this->_cPtr,$pfxFilename,$pfxPassword);
	}

	function SleepMs($millisec) {
		CkSocket_SleepMs($this->_cPtr,$millisec);
	}

	function SshAuthenticatePk($sshLogin,$privateKey) {
		return CkSocket_SshAuthenticatePk($this->_cPtr,$sshLogin,$privateKey);
	}

	function SshAuthenticatePkAsync($sshLogin,$privateKey) {
		$r=CkSocket_SshAuthenticatePkAsync($this->_cPtr,$sshLogin,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshAuthenticatePw($sshLogin,$sshPassword) {
		return CkSocket_SshAuthenticatePw($this->_cPtr,$sshLogin,$sshPassword);
	}

	function SshAuthenticatePwAsync($sshLogin,$sshPassword) {
		$r=CkSocket_SshAuthenticatePwAsync($this->_cPtr,$sshLogin,$sshPassword);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshCloseTunnel() {
		return CkSocket_SshCloseTunnel($this->_cPtr);
	}

	function SshCloseTunnelAsync() {
		$r=CkSocket_SshCloseTunnelAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshNewChannel($hostname,$port,$ssl,$maxWaitMs,$channel) {
		return CkSocket_SshNewChannel($this->_cPtr,$hostname,$port,$ssl,$maxWaitMs,$channel);
	}

	function SshNewChannelAsync($hostname,$port,$ssl,$maxWaitMs,$channel) {
		$r=CkSocket_SshNewChannelAsync($this->_cPtr,$hostname,$port,$ssl,$maxWaitMs,$channel);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshOpenChannel($hostname,$port,$ssl,$maxWaitMs) {
		$r=CkSocket_SshOpenChannel($this->_cPtr,$hostname,$port,$ssl,$maxWaitMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkSocket($r);
		}
		return $r;
	}

	function SshOpenChannelAsync($hostname,$port,$ssl,$maxWaitMs) {
		$r=CkSocket_SshOpenChannelAsync($this->_cPtr,$hostname,$port,$ssl,$maxWaitMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SshOpenTunnel($sshHostname,$sshPort) {
		return CkSocket_SshOpenTunnel($this->_cPtr,$sshHostname,$sshPort);
	}

	function SshOpenTunnelAsync($sshHostname,$sshPort) {
		$r=CkSocket_SshOpenTunnelAsync($this->_cPtr,$sshHostname,$sshPort);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function StartTiming() {
		CkSocket_StartTiming($this->_cPtr);
	}

	function TakeConnection($sock) {
		return CkSocket_TakeConnection($this->_cPtr,$sock);
	}

	function TakeSocket($sock) {
		return CkSocket_TakeSocket($this->_cPtr,$sock);
	}

	function TlsRenegotiate() {
		return CkSocket_TlsRenegotiate($this->_cPtr);
	}

	function TlsRenegotiateAsync() {
		$r=CkSocket_TlsRenegotiateAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UseSsh($ssh) {
		return CkSocket_UseSsh($this->_cPtr,$ssh);
	}
}

class CkSpider {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSpider') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSpider();
	}

	function get_Utf8() {
		return CkSpider_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSpider_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkSpider_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkSpider_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkSpider_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_AvoidHttps() {
		return CkSpider_get_AvoidHttps($this->_cPtr);
	}

	function put_AvoidHttps($newVal) {
		CkSpider_put_AvoidHttps($this->_cPtr,$newVal);
	}

	function get_CacheDir($str) {
		CkSpider_get_CacheDir($this->_cPtr,$str);
	}

	function cacheDir() {
		return CkSpider_cacheDir($this->_cPtr);
	}

	function put_CacheDir($newVal) {
		CkSpider_put_CacheDir($this->_cPtr,$newVal);
	}

	function get_ChopAtQuery() {
		return CkSpider_get_ChopAtQuery($this->_cPtr);
	}

	function put_ChopAtQuery($newVal) {
		CkSpider_put_ChopAtQuery($this->_cPtr,$newVal);
	}

	function get_ConnectTimeout() {
		return CkSpider_get_ConnectTimeout($this->_cPtr);
	}

	function put_ConnectTimeout($newVal) {
		CkSpider_put_ConnectTimeout($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkSpider_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSpider_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSpider_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Domain($str) {
		CkSpider_get_Domain($this->_cPtr,$str);
	}

	function domain() {
		return CkSpider_domain($this->_cPtr);
	}

	function get_FetchFromCache() {
		return CkSpider_get_FetchFromCache($this->_cPtr);
	}

	function put_FetchFromCache($newVal) {
		CkSpider_put_FetchFromCache($this->_cPtr,$newVal);
	}

	function get_FinalRedirectUrl($str) {
		CkSpider_get_FinalRedirectUrl($this->_cPtr,$str);
	}

	function finalRedirectUrl() {
		return CkSpider_finalRedirectUrl($this->_cPtr);
	}

	function get_HeartbeatMs() {
		return CkSpider_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkSpider_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkSpider_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSpider_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSpider_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSpider_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSpider_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSpider_lastErrorXml($this->_cPtr);
	}

	function get_LastFromCache() {
		return CkSpider_get_LastFromCache($this->_cPtr);
	}

	function get_LastHtml($str) {
		CkSpider_get_LastHtml($this->_cPtr,$str);
	}

	function lastHtml() {
		return CkSpider_lastHtml($this->_cPtr);
	}

	function get_LastHtmlDescription($str) {
		CkSpider_get_LastHtmlDescription($this->_cPtr,$str);
	}

	function lastHtmlDescription() {
		return CkSpider_lastHtmlDescription($this->_cPtr);
	}

	function get_LastHtmlKeywords($str) {
		CkSpider_get_LastHtmlKeywords($this->_cPtr,$str);
	}

	function lastHtmlKeywords() {
		return CkSpider_lastHtmlKeywords($this->_cPtr);
	}

	function get_LastHtmlTitle($str) {
		CkSpider_get_LastHtmlTitle($this->_cPtr,$str);
	}

	function lastHtmlTitle() {
		return CkSpider_lastHtmlTitle($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSpider_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSpider_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_LastModDateStr($str) {
		CkSpider_get_LastModDateStr($this->_cPtr,$str);
	}

	function lastModDateStr() {
		return CkSpider_lastModDateStr($this->_cPtr);
	}

	function get_LastUrl($str) {
		CkSpider_get_LastUrl($this->_cPtr,$str);
	}

	function lastUrl() {
		return CkSpider_lastUrl($this->_cPtr);
	}

	function get_MaxResponseSize() {
		return CkSpider_get_MaxResponseSize($this->_cPtr);
	}

	function put_MaxResponseSize($newVal) {
		CkSpider_put_MaxResponseSize($this->_cPtr,$newVal);
	}

	function get_MaxUrlLen() {
		return CkSpider_get_MaxUrlLen($this->_cPtr);
	}

	function put_MaxUrlLen($newVal) {
		CkSpider_put_MaxUrlLen($this->_cPtr,$newVal);
	}

	function get_NumAvoidPatterns() {
		return CkSpider_get_NumAvoidPatterns($this->_cPtr);
	}

	function get_NumFailed() {
		return CkSpider_get_NumFailed($this->_cPtr);
	}

	function get_NumOutboundLinks() {
		return CkSpider_get_NumOutboundLinks($this->_cPtr);
	}

	function get_NumSpidered() {
		return CkSpider_get_NumSpidered($this->_cPtr);
	}

	function get_NumUnspidered() {
		return CkSpider_get_NumUnspidered($this->_cPtr);
	}

	function get_PreferIpv6() {
		return CkSpider_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkSpider_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_ProxyDomain($str) {
		CkSpider_get_ProxyDomain($this->_cPtr,$str);
	}

	function proxyDomain() {
		return CkSpider_proxyDomain($this->_cPtr);
	}

	function put_ProxyDomain($newVal) {
		CkSpider_put_ProxyDomain($this->_cPtr,$newVal);
	}

	function get_ProxyLogin($str) {
		CkSpider_get_ProxyLogin($this->_cPtr,$str);
	}

	function proxyLogin() {
		return CkSpider_proxyLogin($this->_cPtr);
	}

	function put_ProxyLogin($newVal) {
		CkSpider_put_ProxyLogin($this->_cPtr,$newVal);
	}

	function get_ProxyPassword($str) {
		CkSpider_get_ProxyPassword($this->_cPtr,$str);
	}

	function proxyPassword() {
		return CkSpider_proxyPassword($this->_cPtr);
	}

	function put_ProxyPassword($newVal) {
		CkSpider_put_ProxyPassword($this->_cPtr,$newVal);
	}

	function get_ProxyPort() {
		return CkSpider_get_ProxyPort($this->_cPtr);
	}

	function put_ProxyPort($newVal) {
		CkSpider_put_ProxyPort($this->_cPtr,$newVal);
	}

	function get_ReadTimeout() {
		return CkSpider_get_ReadTimeout($this->_cPtr);
	}

	function put_ReadTimeout($newVal) {
		CkSpider_put_ReadTimeout($this->_cPtr,$newVal);
	}

	function get_UpdateCache() {
		return CkSpider_get_UpdateCache($this->_cPtr);
	}

	function put_UpdateCache($newVal) {
		CkSpider_put_UpdateCache($this->_cPtr,$newVal);
	}

	function get_UserAgent($str) {
		CkSpider_get_UserAgent($this->_cPtr,$str);
	}

	function userAgent() {
		return CkSpider_userAgent($this->_cPtr);
	}

	function put_UserAgent($newVal) {
		CkSpider_put_UserAgent($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkSpider_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSpider_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSpider_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSpider_version($this->_cPtr);
	}

	function get_WasRedirected() {
		return CkSpider_get_WasRedirected($this->_cPtr);
	}

	function get_WindDownCount() {
		return CkSpider_get_WindDownCount($this->_cPtr);
	}

	function put_WindDownCount($newVal) {
		CkSpider_put_WindDownCount($this->_cPtr,$newVal);
	}

	function AddAvoidOutboundLinkPattern($pattern) {
		CkSpider_AddAvoidOutboundLinkPattern($this->_cPtr,$pattern);
	}

	function AddAvoidPattern($pattern) {
		CkSpider_AddAvoidPattern($this->_cPtr,$pattern);
	}

	function AddMustMatchPattern($pattern) {
		CkSpider_AddMustMatchPattern($this->_cPtr,$pattern);
	}

	function AddUnspidered($url) {
		CkSpider_AddUnspidered($this->_cPtr,$url);
	}

	function canonicalizeUrl($url) {
		return CkSpider_canonicalizeUrl($this->_cPtr,$url);
	}

	function ClearFailedUrls() {
		CkSpider_ClearFailedUrls($this->_cPtr);
	}

	function ClearOutboundLinks() {
		CkSpider_ClearOutboundLinks($this->_cPtr);
	}

	function ClearSpideredUrls() {
		CkSpider_ClearSpideredUrls($this->_cPtr);
	}

	function CrawlNext() {
		return CkSpider_CrawlNext($this->_cPtr);
	}

	function CrawlNextAsync() {
		$r=CkSpider_CrawlNextAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function fetchRobotsText() {
		return CkSpider_fetchRobotsText($this->_cPtr);
	}

	function FetchRobotsTextAsync() {
		$r=CkSpider_FetchRobotsTextAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function getAvoidPattern($index) {
		return CkSpider_getAvoidPattern($this->_cPtr,$index);
	}

	function avoidPattern($index) {
		return CkSpider_avoidPattern($this->_cPtr,$index);
	}

	function getBaseDomain($domain) {
		return CkSpider_getBaseDomain($this->_cPtr,$domain);
	}

	function baseDomain($domain) {
		return CkSpider_baseDomain($this->_cPtr,$domain);
	}

	function getFailedUrl($index) {
		return CkSpider_getFailedUrl($this->_cPtr,$index);
	}

	function failedUrl($index) {
		return CkSpider_failedUrl($this->_cPtr,$index);
	}

	function getOutboundLink($index) {
		return CkSpider_getOutboundLink($this->_cPtr,$index);
	}

	function outboundLink($index) {
		return CkSpider_outboundLink($this->_cPtr,$index);
	}

	function getSpideredUrl($index) {
		return CkSpider_getSpideredUrl($this->_cPtr,$index);
	}

	function spideredUrl($index) {
		return CkSpider_spideredUrl($this->_cPtr,$index);
	}

	function getUnspideredUrl($index) {
		return CkSpider_getUnspideredUrl($this->_cPtr,$index);
	}

	function unspideredUrl($index) {
		return CkSpider_unspideredUrl($this->_cPtr,$index);
	}

	function getUrlDomain($url) {
		return CkSpider_getUrlDomain($this->_cPtr,$url);
	}

	function urlDomain($url) {
		return CkSpider_urlDomain($this->_cPtr,$url);
	}

	function Initialize($domain) {
		CkSpider_Initialize($this->_cPtr,$domain);
	}

	function LoadTaskCaller($task) {
		return CkSpider_LoadTaskCaller($this->_cPtr,$task);
	}

	function RecrawlLast() {
		return CkSpider_RecrawlLast($this->_cPtr);
	}

	function RecrawlLastAsync() {
		$r=CkSpider_RecrawlLastAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SkipUnspidered($index) {
		CkSpider_SkipUnspidered($this->_cPtr,$index);
	}

	function SleepMs($numMilliseconds) {
		CkSpider_SleepMs($this->_cPtr,$numMilliseconds);
	}
}

class CkSsh {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSsh') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSsh();
	}

	function get_Utf8() {
		return CkSsh_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSsh_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkSsh_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkSsh_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkSsh_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_AuthFailReason() {
		return CkSsh_get_AuthFailReason($this->_cPtr);
	}

	function get_CaretControl() {
		return CkSsh_get_CaretControl($this->_cPtr);
	}

	function put_CaretControl($newVal) {
		CkSsh_put_CaretControl($this->_cPtr,$newVal);
	}

	function get_ChannelOpenFailCode() {
		return CkSsh_get_ChannelOpenFailCode($this->_cPtr);
	}

	function get_ChannelOpenFailReason($str) {
		CkSsh_get_ChannelOpenFailReason($this->_cPtr,$str);
	}

	function channelOpenFailReason() {
		return CkSsh_channelOpenFailReason($this->_cPtr);
	}

	function get_ClientIdentifier($str) {
		CkSsh_get_ClientIdentifier($this->_cPtr,$str);
	}

	function clientIdentifier() {
		return CkSsh_clientIdentifier($this->_cPtr);
	}

	function put_ClientIdentifier($newVal) {
		CkSsh_put_ClientIdentifier($this->_cPtr,$newVal);
	}

	function get_ClientIpAddress($str) {
		CkSsh_get_ClientIpAddress($this->_cPtr,$str);
	}

	function clientIpAddress() {
		return CkSsh_clientIpAddress($this->_cPtr);
	}

	function put_ClientIpAddress($newVal) {
		CkSsh_put_ClientIpAddress($this->_cPtr,$newVal);
	}

	function get_ClientPort() {
		return CkSsh_get_ClientPort($this->_cPtr);
	}

	function put_ClientPort($newVal) {
		CkSsh_put_ClientPort($this->_cPtr,$newVal);
	}

	function get_ConnectTimeoutMs() {
		return CkSsh_get_ConnectTimeoutMs($this->_cPtr);
	}

	function put_ConnectTimeoutMs($newVal) {
		CkSsh_put_ConnectTimeoutMs($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkSsh_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSsh_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSsh_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DisconnectCode() {
		return CkSsh_get_DisconnectCode($this->_cPtr);
	}

	function get_DisconnectReason($str) {
		CkSsh_get_DisconnectReason($this->_cPtr,$str);
	}

	function disconnectReason() {
		return CkSsh_disconnectReason($this->_cPtr);
	}

	function get_EnableCompression() {
		return CkSsh_get_EnableCompression($this->_cPtr);
	}

	function put_EnableCompression($newVal) {
		CkSsh_put_EnableCompression($this->_cPtr,$newVal);
	}

	function get_ForceCipher($str) {
		CkSsh_get_ForceCipher($this->_cPtr,$str);
	}

	function forceCipher() {
		return CkSsh_forceCipher($this->_cPtr);
	}

	function put_ForceCipher($newVal) {
		CkSsh_put_ForceCipher($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkSsh_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkSsh_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_HostKeyAlg($str) {
		CkSsh_get_HostKeyAlg($this->_cPtr,$str);
	}

	function hostKeyAlg() {
		return CkSsh_hostKeyAlg($this->_cPtr);
	}

	function put_HostKeyAlg($newVal) {
		CkSsh_put_HostKeyAlg($this->_cPtr,$newVal);
	}

	function get_HostKeyFingerprint($str) {
		CkSsh_get_HostKeyFingerprint($this->_cPtr,$str);
	}

	function hostKeyFingerprint() {
		return CkSsh_hostKeyFingerprint($this->_cPtr);
	}

	function get_HttpProxyAuthMethod($str) {
		CkSsh_get_HttpProxyAuthMethod($this->_cPtr,$str);
	}

	function httpProxyAuthMethod() {
		return CkSsh_httpProxyAuthMethod($this->_cPtr);
	}

	function put_HttpProxyAuthMethod($newVal) {
		CkSsh_put_HttpProxyAuthMethod($this->_cPtr,$newVal);
	}

	function get_HttpProxyDomain($str) {
		CkSsh_get_HttpProxyDomain($this->_cPtr,$str);
	}

	function httpProxyDomain() {
		return CkSsh_httpProxyDomain($this->_cPtr);
	}

	function put_HttpProxyDomain($newVal) {
		CkSsh_put_HttpProxyDomain($this->_cPtr,$newVal);
	}

	function get_HttpProxyHostname($str) {
		CkSsh_get_HttpProxyHostname($this->_cPtr,$str);
	}

	function httpProxyHostname() {
		return CkSsh_httpProxyHostname($this->_cPtr);
	}

	function put_HttpProxyHostname($newVal) {
		CkSsh_put_HttpProxyHostname($this->_cPtr,$newVal);
	}

	function get_HttpProxyPassword($str) {
		CkSsh_get_HttpProxyPassword($this->_cPtr,$str);
	}

	function httpProxyPassword() {
		return CkSsh_httpProxyPassword($this->_cPtr);
	}

	function put_HttpProxyPassword($newVal) {
		CkSsh_put_HttpProxyPassword($this->_cPtr,$newVal);
	}

	function get_HttpProxyPort() {
		return CkSsh_get_HttpProxyPort($this->_cPtr);
	}

	function put_HttpProxyPort($newVal) {
		CkSsh_put_HttpProxyPort($this->_cPtr,$newVal);
	}

	function get_HttpProxyUsername($str) {
		CkSsh_get_HttpProxyUsername($this->_cPtr,$str);
	}

	function httpProxyUsername() {
		return CkSsh_httpProxyUsername($this->_cPtr);
	}

	function put_HttpProxyUsername($newVal) {
		CkSsh_put_HttpProxyUsername($this->_cPtr,$newVal);
	}

	function get_IdleTimeoutMs() {
		return CkSsh_get_IdleTimeoutMs($this->_cPtr);
	}

	function put_IdleTimeoutMs($newVal) {
		CkSsh_put_IdleTimeoutMs($this->_cPtr,$newVal);
	}

	function get_IsConnected() {
		return CkSsh_get_IsConnected($this->_cPtr);
	}

	function get_KeepSessionLog() {
		return CkSsh_get_KeepSessionLog($this->_cPtr);
	}

	function put_KeepSessionLog($newVal) {
		CkSsh_put_KeepSessionLog($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkSsh_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSsh_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSsh_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSsh_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSsh_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSsh_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSsh_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSsh_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_MaxPacketSize() {
		return CkSsh_get_MaxPacketSize($this->_cPtr);
	}

	function put_MaxPacketSize($newVal) {
		CkSsh_put_MaxPacketSize($this->_cPtr,$newVal);
	}

	function get_NumOpenChannels() {
		return CkSsh_get_NumOpenChannels($this->_cPtr);
	}

	function get_PasswordChangeRequested() {
		return CkSsh_get_PasswordChangeRequested($this->_cPtr);
	}

	function get_PreferIpv6() {
		return CkSsh_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkSsh_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_ReadTimeoutMs() {
		return CkSsh_get_ReadTimeoutMs($this->_cPtr);
	}

	function put_ReadTimeoutMs($newVal) {
		CkSsh_put_ReadTimeoutMs($this->_cPtr,$newVal);
	}

	function get_ReqExecCharset($str) {
		CkSsh_get_ReqExecCharset($this->_cPtr,$str);
	}

	function reqExecCharset() {
		return CkSsh_reqExecCharset($this->_cPtr);
	}

	function put_ReqExecCharset($newVal) {
		CkSsh_put_ReqExecCharset($this->_cPtr,$newVal);
	}

	function get_ServerIdentifier($str) {
		CkSsh_get_ServerIdentifier($this->_cPtr,$str);
	}

	function serverIdentifier() {
		return CkSsh_serverIdentifier($this->_cPtr);
	}

	function get_SessionLog($str) {
		CkSsh_get_SessionLog($this->_cPtr,$str);
	}

	function sessionLog() {
		return CkSsh_sessionLog($this->_cPtr);
	}

	function get_SocksHostname($str) {
		CkSsh_get_SocksHostname($this->_cPtr,$str);
	}

	function socksHostname() {
		return CkSsh_socksHostname($this->_cPtr);
	}

	function put_SocksHostname($newVal) {
		CkSsh_put_SocksHostname($this->_cPtr,$newVal);
	}

	function get_SocksPassword($str) {
		CkSsh_get_SocksPassword($this->_cPtr,$str);
	}

	function socksPassword() {
		return CkSsh_socksPassword($this->_cPtr);
	}

	function put_SocksPassword($newVal) {
		CkSsh_put_SocksPassword($this->_cPtr,$newVal);
	}

	function get_SocksPort() {
		return CkSsh_get_SocksPort($this->_cPtr);
	}

	function put_SocksPort($newVal) {
		CkSsh_put_SocksPort($this->_cPtr,$newVal);
	}

	function get_SocksUsername($str) {
		CkSsh_get_SocksUsername($this->_cPtr,$str);
	}

	function socksUsername() {
		return CkSsh_socksUsername($this->_cPtr);
	}

	function put_SocksUsername($newVal) {
		CkSsh_put_SocksUsername($this->_cPtr,$newVal);
	}

	function get_SocksVersion() {
		return CkSsh_get_SocksVersion($this->_cPtr);
	}

	function put_SocksVersion($newVal) {
		CkSsh_put_SocksVersion($this->_cPtr,$newVal);
	}

	function get_SoRcvBuf() {
		return CkSsh_get_SoRcvBuf($this->_cPtr);
	}

	function put_SoRcvBuf($newVal) {
		CkSsh_put_SoRcvBuf($this->_cPtr,$newVal);
	}

	function get_SoSndBuf() {
		return CkSsh_get_SoSndBuf($this->_cPtr);
	}

	function put_SoSndBuf($newVal) {
		CkSsh_put_SoSndBuf($this->_cPtr,$newVal);
	}

	function get_StderrToStdout() {
		return CkSsh_get_StderrToStdout($this->_cPtr);
	}

	function put_StderrToStdout($newVal) {
		CkSsh_put_StderrToStdout($this->_cPtr,$newVal);
	}

	function get_StripColorCodes() {
		return CkSsh_get_StripColorCodes($this->_cPtr);
	}

	function put_StripColorCodes($newVal) {
		CkSsh_put_StripColorCodes($this->_cPtr,$newVal);
	}

	function get_TcpNoDelay() {
		return CkSsh_get_TcpNoDelay($this->_cPtr);
	}

	function put_TcpNoDelay($newVal) {
		CkSsh_put_TcpNoDelay($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkSsh_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkSsh_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkSsh_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_UserAuthBanner($str) {
		CkSsh_get_UserAuthBanner($this->_cPtr,$str);
	}

	function userAuthBanner() {
		return CkSsh_userAuthBanner($this->_cPtr);
	}

	function put_UserAuthBanner($newVal) {
		CkSsh_put_UserAuthBanner($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkSsh_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSsh_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSsh_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSsh_version($this->_cPtr);
	}

	function AuthenticatePk($username,$privateKey) {
		return CkSsh_AuthenticatePk($this->_cPtr,$username,$privateKey);
	}

	function AuthenticatePkAsync($username,$privateKey) {
		$r=CkSsh_AuthenticatePkAsync($this->_cPtr,$username,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticatePw($login,$password) {
		return CkSsh_AuthenticatePw($this->_cPtr,$login,$password);
	}

	function AuthenticatePwAsync($login,$password) {
		$r=CkSsh_AuthenticatePwAsync($this->_cPtr,$login,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticatePwPk($username,$password,$privateKey) {
		return CkSsh_AuthenticatePwPk($this->_cPtr,$username,$password,$privateKey);
	}

	function AuthenticatePwPkAsync($username,$password,$privateKey) {
		$r=CkSsh_AuthenticatePwPkAsync($this->_cPtr,$username,$password,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticateSecPw($login,$password) {
		return CkSsh_AuthenticateSecPw($this->_cPtr,$login,$password);
	}

	function AuthenticateSecPwAsync($login,$password) {
		$r=CkSsh_AuthenticateSecPwAsync($this->_cPtr,$login,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticateSecPwPk($username,$password,$privateKey) {
		return CkSsh_AuthenticateSecPwPk($this->_cPtr,$username,$password,$privateKey);
	}

	function AuthenticateSecPwPkAsync($username,$password,$privateKey) {
		$r=CkSsh_AuthenticateSecPwPkAsync($this->_cPtr,$username,$password,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelIsOpen($channelNum) {
		return CkSsh_ChannelIsOpen($this->_cPtr,$channelNum);
	}

	function ChannelPoll($channelNum,$pollTimeoutMs) {
		return CkSsh_ChannelPoll($this->_cPtr,$channelNum,$pollTimeoutMs);
	}

	function ChannelPollAsync($channelNum,$pollTimeoutMs) {
		$r=CkSsh_ChannelPollAsync($this->_cPtr,$channelNum,$pollTimeoutMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelRead($channelNum) {
		return CkSsh_ChannelRead($this->_cPtr,$channelNum);
	}

	function ChannelReadAsync($channelNum) {
		$r=CkSsh_ChannelReadAsync($this->_cPtr,$channelNum);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelReadAndPoll($channelNum,$pollTimeoutMs) {
		return CkSsh_ChannelReadAndPoll($this->_cPtr,$channelNum,$pollTimeoutMs);
	}

	function ChannelReadAndPollAsync($channelNum,$pollTimeoutMs) {
		$r=CkSsh_ChannelReadAndPollAsync($this->_cPtr,$channelNum,$pollTimeoutMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelReadAndPoll2($channelNum,$pollTimeoutMs,$maxNumBytes) {
		return CkSsh_ChannelReadAndPoll2($this->_cPtr,$channelNum,$pollTimeoutMs,$maxNumBytes);
	}

	function ChannelReadAndPoll2Async($channelNum,$pollTimeoutMs,$maxNumBytes) {
		$r=CkSsh_ChannelReadAndPoll2Async($this->_cPtr,$channelNum,$pollTimeoutMs,$maxNumBytes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelReceivedClose($channelNum) {
		return CkSsh_ChannelReceivedClose($this->_cPtr,$channelNum);
	}

	function ChannelReceivedEof($channelNum) {
		return CkSsh_ChannelReceivedEof($this->_cPtr,$channelNum);
	}

	function ChannelReceivedExitStatus($channelNum) {
		return CkSsh_ChannelReceivedExitStatus($this->_cPtr,$channelNum);
	}

	function ChannelReceiveToClose($channelNum) {
		return CkSsh_ChannelReceiveToClose($this->_cPtr,$channelNum);
	}

	function ChannelReceiveToCloseAsync($channelNum) {
		$r=CkSsh_ChannelReceiveToCloseAsync($this->_cPtr,$channelNum);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelReceiveUntilMatch($channelNum,$matchPattern,$charset,$caseSensitive) {
		return CkSsh_ChannelReceiveUntilMatch($this->_cPtr,$channelNum,$matchPattern,$charset,$caseSensitive);
	}

	function ChannelReceiveUntilMatchAsync($channelNum,$matchPattern,$charset,$caseSensitive) {
		$r=CkSsh_ChannelReceiveUntilMatchAsync($this->_cPtr,$channelNum,$matchPattern,$charset,$caseSensitive);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelReceiveUntilMatchN($channelNum,$matchPatterns,$charset,$caseSensitive) {
		return CkSsh_ChannelReceiveUntilMatchN($this->_cPtr,$channelNum,$matchPatterns,$charset,$caseSensitive);
	}

	function ChannelReceiveUntilMatchNAsync($channelNum,$matchPatterns,$charset,$caseSensitive) {
		$r=CkSsh_ChannelReceiveUntilMatchNAsync($this->_cPtr,$channelNum,$matchPatterns,$charset,$caseSensitive);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelRelease($channelNum) {
		CkSsh_ChannelRelease($this->_cPtr,$channelNum);
	}

	function ChannelSendClose($channelNum) {
		return CkSsh_ChannelSendClose($this->_cPtr,$channelNum);
	}

	function ChannelSendCloseAsync($channelNum) {
		$r=CkSsh_ChannelSendCloseAsync($this->_cPtr,$channelNum);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelSendData($channelNum,$byteData) {
		return CkSsh_ChannelSendData($this->_cPtr,$channelNum,$byteData);
	}

	function ChannelSendDataAsync($channelNum,$byteData) {
		$r=CkSsh_ChannelSendDataAsync($this->_cPtr,$channelNum,$byteData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelSendEof($channelNum) {
		return CkSsh_ChannelSendEof($this->_cPtr,$channelNum);
	}

	function ChannelSendEofAsync($channelNum) {
		$r=CkSsh_ChannelSendEofAsync($this->_cPtr,$channelNum);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ChannelSendString($channelNum,$textData,$charset) {
		return CkSsh_ChannelSendString($this->_cPtr,$channelNum,$textData,$charset);
	}

	function ChannelSendStringAsync($channelNum,$textData,$charset) {
		$r=CkSsh_ChannelSendStringAsync($this->_cPtr,$channelNum,$textData,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CheckConnection() {
		return CkSsh_CheckConnection($this->_cPtr);
	}

	function ClearTtyModes() {
		CkSsh_ClearTtyModes($this->_cPtr);
	}

	function Connect($domainName,$port) {
		return CkSsh_Connect($this->_cPtr,$domainName,$port);
	}

	function ConnectAsync($domainName,$port) {
		$r=CkSsh_ConnectAsync($this->_cPtr,$domainName,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ConnectThroughSsh($ssh,$hostname,$port) {
		return CkSsh_ConnectThroughSsh($this->_cPtr,$ssh,$hostname,$port);
	}

	function ConnectThroughSshAsync($ssh,$hostname,$port) {
		$r=CkSsh_ConnectThroughSshAsync($this->_cPtr,$ssh,$hostname,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function continueKeyboardAuth($response) {
		return CkSsh_continueKeyboardAuth($this->_cPtr,$response);
	}

	function ContinueKeyboardAuthAsync($response) {
		$r=CkSsh_ContinueKeyboardAuthAsync($this->_cPtr,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Disconnect() {
		CkSsh_Disconnect($this->_cPtr);
	}

	function getAuthMethods() {
		return CkSsh_getAuthMethods($this->_cPtr);
	}

	function authMethods() {
		return CkSsh_authMethods($this->_cPtr);
	}

	function GetAuthMethodsAsync() {
		$r=CkSsh_GetAuthMethodsAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetChannelExitStatus($channelNum) {
		return CkSsh_GetChannelExitStatus($this->_cPtr,$channelNum);
	}

	function GetChannelNumber($index) {
		return CkSsh_GetChannelNumber($this->_cPtr,$index);
	}

	function getChannelType($index) {
		return CkSsh_getChannelType($this->_cPtr,$index);
	}

	function channelType($index) {
		return CkSsh_channelType($this->_cPtr,$index);
	}

	function getHostKeyFP($hashAlg,$includeKeyType,$includeHashName) {
		return CkSsh_getHostKeyFP($this->_cPtr,$hashAlg,$includeKeyType,$includeHashName);
	}

	function hostKeyFP($hashAlg,$includeKeyType,$includeHashName) {
		return CkSsh_hostKeyFP($this->_cPtr,$hashAlg,$includeKeyType,$includeHashName);
	}

	function GetLastJsonData($json) {
		CkSsh_GetLastJsonData($this->_cPtr,$json);
	}

	function GetReceivedData($channelNum,$outBytes) {
		return CkSsh_GetReceivedData($this->_cPtr,$channelNum,$outBytes);
	}

	function GetReceivedDataN($channelNum,$maxNumBytes,$outBytes) {
		return CkSsh_GetReceivedDataN($this->_cPtr,$channelNum,$maxNumBytes,$outBytes);
	}

	function GetReceivedNumBytes($channelNum) {
		return CkSsh_GetReceivedNumBytes($this->_cPtr,$channelNum);
	}

	function GetReceivedStderr($channelNum,$outBytes) {
		return CkSsh_GetReceivedStderr($this->_cPtr,$channelNum,$outBytes);
	}

	function getReceivedStderrText($channelNum,$charset) {
		return CkSsh_getReceivedStderrText($this->_cPtr,$channelNum,$charset);
	}

	function receivedStderrText($channelNum,$charset) {
		return CkSsh_receivedStderrText($this->_cPtr,$channelNum,$charset);
	}

	function getReceivedText($channelNum,$charset) {
		return CkSsh_getReceivedText($this->_cPtr,$channelNum,$charset);
	}

	function receivedText($channelNum,$charset) {
		return CkSsh_receivedText($this->_cPtr,$channelNum,$charset);
	}

	function getReceivedTextS($channelNum,$substr,$charset) {
		return CkSsh_getReceivedTextS($this->_cPtr,$channelNum,$substr,$charset);
	}

	function receivedTextS($channelNum,$substr,$charset) {
		return CkSsh_receivedTextS($this->_cPtr,$channelNum,$substr,$charset);
	}

	function LastJsonData() {
		$r=CkSsh_LastJsonData($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkJsonObject($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkSsh_LoadTaskCaller($this->_cPtr,$task);
	}

	function OpenCustomChannel($channelType) {
		return CkSsh_OpenCustomChannel($this->_cPtr,$channelType);
	}

	function OpenCustomChannelAsync($channelType) {
		$r=CkSsh_OpenCustomChannelAsync($this->_cPtr,$channelType);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function OpenDirectTcpIpChannel($targetHostname,$targetPort) {
		return CkSsh_OpenDirectTcpIpChannel($this->_cPtr,$targetHostname,$targetPort);
	}

	function OpenDirectTcpIpChannelAsync($targetHostname,$targetPort) {
		$r=CkSsh_OpenDirectTcpIpChannelAsync($this->_cPtr,$targetHostname,$targetPort);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function OpenSessionChannel() {
		return CkSsh_OpenSessionChannel($this->_cPtr);
	}

	function OpenSessionChannelAsync() {
		$r=CkSsh_OpenSessionChannelAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function peekReceivedText($channelNum,$charset) {
		return CkSsh_peekReceivedText($this->_cPtr,$channelNum,$charset);
	}

	function QuickCmdCheck($pollTimeoutMs) {
		return CkSsh_QuickCmdCheck($this->_cPtr,$pollTimeoutMs);
	}

	function QuickCmdCheckAsync($pollTimeoutMs) {
		$r=CkSsh_QuickCmdCheckAsync($this->_cPtr,$pollTimeoutMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QuickCmdSend($command) {
		return CkSsh_QuickCmdSend($this->_cPtr,$command);
	}

	function QuickCmdSendAsync($command) {
		$r=CkSsh_QuickCmdSendAsync($this->_cPtr,$command);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function quickCommand($command,$charset) {
		return CkSsh_quickCommand($this->_cPtr,$command,$charset);
	}

	function QuickCommandAsync($command,$charset) {
		$r=CkSsh_QuickCommandAsync($this->_cPtr,$command,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QuickShell() {
		return CkSsh_QuickShell($this->_cPtr);
	}

	function QuickShellAsync() {
		$r=CkSsh_QuickShellAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReKey() {
		return CkSsh_ReKey($this->_cPtr);
	}

	function ReKeyAsync() {
		$r=CkSsh_ReKeyAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendIgnore() {
		return CkSsh_SendIgnore($this->_cPtr);
	}

	function SendIgnoreAsync() {
		$r=CkSsh_SendIgnoreAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqExec($channelNum,$commandLine) {
		return CkSsh_SendReqExec($this->_cPtr,$channelNum,$commandLine);
	}

	function SendReqExecAsync($channelNum,$commandLine) {
		$r=CkSsh_SendReqExecAsync($this->_cPtr,$channelNum,$commandLine);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqPty($channelNum,$termType,$widthInChars,$heightInChars,$widthInPixels,$heightInPixels) {
		return CkSsh_SendReqPty($this->_cPtr,$channelNum,$termType,$widthInChars,$heightInChars,$widthInPixels,$heightInPixels);
	}

	function SendReqPtyAsync($channelNum,$termType,$widthInChars,$heightInChars,$widthInPixels,$heightInPixels) {
		$r=CkSsh_SendReqPtyAsync($this->_cPtr,$channelNum,$termType,$widthInChars,$heightInChars,$widthInPixels,$heightInPixels);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqSetEnv($channelNum,$name,$value) {
		return CkSsh_SendReqSetEnv($this->_cPtr,$channelNum,$name,$value);
	}

	function SendReqSetEnvAsync($channelNum,$name,$value) {
		$r=CkSsh_SendReqSetEnvAsync($this->_cPtr,$channelNum,$name,$value);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqShell($channelNum) {
		return CkSsh_SendReqShell($this->_cPtr,$channelNum);
	}

	function SendReqShellAsync($channelNum) {
		$r=CkSsh_SendReqShellAsync($this->_cPtr,$channelNum);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqSignal($channelNum,$signalName) {
		return CkSsh_SendReqSignal($this->_cPtr,$channelNum,$signalName);
	}

	function SendReqSignalAsync($channelNum,$signalName) {
		$r=CkSsh_SendReqSignalAsync($this->_cPtr,$channelNum,$signalName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqSubsystem($channelNum,$subsystemName) {
		return CkSsh_SendReqSubsystem($this->_cPtr,$channelNum,$subsystemName);
	}

	function SendReqSubsystemAsync($channelNum,$subsystemName) {
		$r=CkSsh_SendReqSubsystemAsync($this->_cPtr,$channelNum,$subsystemName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqWindowChange($channelNum,$widthInChars,$heightInRows,$pixWidth,$pixHeight) {
		return CkSsh_SendReqWindowChange($this->_cPtr,$channelNum,$widthInChars,$heightInRows,$pixWidth,$pixHeight);
	}

	function SendReqWindowChangeAsync($channelNum,$widthInChars,$heightInRows,$pixWidth,$pixHeight) {
		$r=CkSsh_SendReqWindowChangeAsync($this->_cPtr,$channelNum,$widthInChars,$heightInRows,$pixWidth,$pixHeight);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqX11Forwarding($channelNum,$singleConnection,$authProt,$authCookie,$screenNum) {
		return CkSsh_SendReqX11Forwarding($this->_cPtr,$channelNum,$singleConnection,$authProt,$authCookie,$screenNum);
	}

	function SendReqX11ForwardingAsync($channelNum,$singleConnection,$authProt,$authCookie,$screenNum) {
		$r=CkSsh_SendReqX11ForwardingAsync($this->_cPtr,$channelNum,$singleConnection,$authProt,$authCookie,$screenNum);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendReqXonXoff($channelNum,$clientCanDo) {
		return CkSsh_SendReqXonXoff($this->_cPtr,$channelNum,$clientCanDo);
	}

	function SendReqXonXoffAsync($channelNum,$clientCanDo) {
		$r=CkSsh_SendReqXonXoffAsync($this->_cPtr,$channelNum,$clientCanDo);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetAllowedAlgorithms($json) {
		return CkSsh_SetAllowedAlgorithms($this->_cPtr,$json);
	}

	function SetTtyMode($ttyName,$ttyValue) {
		return CkSsh_SetTtyMode($this->_cPtr,$ttyName,$ttyValue);
	}

	function startKeyboardAuth($login) {
		return CkSsh_startKeyboardAuth($this->_cPtr,$login);
	}

	function StartKeyboardAuthAsync($login) {
		$r=CkSsh_StartKeyboardAuthAsync($this->_cPtr,$login);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WaitForChannelMessage($pollTimeoutMs) {
		return CkSsh_WaitForChannelMessage($this->_cPtr,$pollTimeoutMs);
	}

	function WaitForChannelMessageAsync($pollTimeoutMs) {
		$r=CkSsh_WaitForChannelMessageAsync($this->_cPtr,$pollTimeoutMs);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkSshKey {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSshKey') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSshKey();
	}

	function get_Utf8() {
		return CkSshKey_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSshKey_put_Utf8($this->_cPtr,$b);
	}

	function get_Comment($str) {
		CkSshKey_get_Comment($this->_cPtr,$str);
	}

	function comment() {
		return CkSshKey_comment($this->_cPtr);
	}

	function put_Comment($newVal) {
		CkSshKey_put_Comment($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkSshKey_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSshKey_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSshKey_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_IsDsaKey() {
		return CkSshKey_get_IsDsaKey($this->_cPtr);
	}

	function get_IsPrivateKey() {
		return CkSshKey_get_IsPrivateKey($this->_cPtr);
	}

	function get_IsRsaKey() {
		return CkSshKey_get_IsRsaKey($this->_cPtr);
	}

	function get_KeyType($str) {
		CkSshKey_get_KeyType($this->_cPtr,$str);
	}

	function keyType() {
		return CkSshKey_keyType($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkSshKey_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSshKey_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSshKey_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSshKey_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSshKey_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSshKey_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSshKey_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSshKey_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Password($str) {
		CkSshKey_get_Password($this->_cPtr,$str);
	}

	function password() {
		return CkSshKey_password($this->_cPtr);
	}

	function put_Password($newVal) {
		CkSshKey_put_Password($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkSshKey_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkSshKey_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkSshKey_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkSshKey_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSshKey_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSshKey_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSshKey_version($this->_cPtr);
	}

	function FromOpenSshPrivateKey($keyStr) {
		return CkSshKey_FromOpenSshPrivateKey($this->_cPtr,$keyStr);
	}

	function FromOpenSshPublicKey($keyStr) {
		return CkSshKey_FromOpenSshPublicKey($this->_cPtr,$keyStr);
	}

	function FromPuttyPrivateKey($keyStr) {
		return CkSshKey_FromPuttyPrivateKey($this->_cPtr,$keyStr);
	}

	function FromRfc4716PublicKey($keyStr) {
		return CkSshKey_FromRfc4716PublicKey($this->_cPtr,$keyStr);
	}

	function FromXml($xmlKey) {
		return CkSshKey_FromXml($this->_cPtr,$xmlKey);
	}

	function GenerateDsaKey($numBits) {
		return CkSshKey_GenerateDsaKey($this->_cPtr,$numBits);
	}

	function GenerateEcdsaKey($curveName) {
		return CkSshKey_GenerateEcdsaKey($this->_cPtr,$curveName);
	}

	function GenerateEd25519Key() {
		return CkSshKey_GenerateEd25519Key($this->_cPtr);
	}

	function GenerateRsaKey($numBits,$exponent) {
		return CkSshKey_GenerateRsaKey($this->_cPtr,$numBits,$exponent);
	}

	function genFingerprint() {
		return CkSshKey_genFingerprint($this->_cPtr);
	}

	function loadText($filename) {
		return CkSshKey_loadText($this->_cPtr,$filename);
	}

	function SaveText($strToSave,$filename) {
		return CkSshKey_SaveText($this->_cPtr,$strToSave,$filename);
	}

	function toOpenSshPrivateKey($bEncrypt) {
		return CkSshKey_toOpenSshPrivateKey($this->_cPtr,$bEncrypt);
	}

	function toOpenSshPublicKey() {
		return CkSshKey_toOpenSshPublicKey($this->_cPtr);
	}

	function toPuttyPrivateKey($bEncrypt) {
		return CkSshKey_toPuttyPrivateKey($this->_cPtr,$bEncrypt);
	}

	function toRfc4716PublicKey() {
		return CkSshKey_toRfc4716PublicKey($this->_cPtr);
	}

	function toXml() {
		return CkSshKey_toXml($this->_cPtr);
	}

	function UsePkcs11($session,$privKeyHandle,$pubKeyHandle,$keyType) {
		return CkSshKey_UsePkcs11($this->_cPtr,$session,$privKeyHandle,$pubKeyHandle,$keyType);
	}

	function UseSshCertificate($sshCert) {
		return CkSshKey_UseSshCertificate($this->_cPtr,$sshCert);
	}
}

class CkSshTunnel {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkSshTunnel') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkSshTunnel();
	}

	function get_Utf8() {
		return CkSshTunnel_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkSshTunnel_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkSshTunnel_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkSshTunnel_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkSshTunnel_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_AcceptLog($str) {
		CkSshTunnel_get_AcceptLog($this->_cPtr,$str);
	}

	function acceptLog() {
		return CkSshTunnel_acceptLog($this->_cPtr);
	}

	function put_AcceptLog($newVal) {
		CkSshTunnel_put_AcceptLog($this->_cPtr,$newVal);
	}

	function get_AcceptLogPath($str) {
		CkSshTunnel_get_AcceptLogPath($this->_cPtr,$str);
	}

	function acceptLogPath() {
		return CkSshTunnel_acceptLogPath($this->_cPtr);
	}

	function put_AcceptLogPath($newVal) {
		CkSshTunnel_put_AcceptLogPath($this->_cPtr,$newVal);
	}

	function get_ClientIdentifier($str) {
		CkSshTunnel_get_ClientIdentifier($this->_cPtr,$str);
	}

	function clientIdentifier() {
		return CkSshTunnel_clientIdentifier($this->_cPtr);
	}

	function put_ClientIdentifier($newVal) {
		CkSshTunnel_put_ClientIdentifier($this->_cPtr,$newVal);
	}

	function get_ClientLogDir($str) {
		CkSshTunnel_get_ClientLogDir($this->_cPtr,$str);
	}

	function clientLogDir() {
		return CkSshTunnel_clientLogDir($this->_cPtr);
	}

	function put_ClientLogDir($newVal) {
		CkSshTunnel_put_ClientLogDir($this->_cPtr,$newVal);
	}

	function get_ConnectTimeoutMs() {
		return CkSshTunnel_get_ConnectTimeoutMs($this->_cPtr);
	}

	function put_ConnectTimeoutMs($newVal) {
		CkSshTunnel_put_ConnectTimeoutMs($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkSshTunnel_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkSshTunnel_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkSshTunnel_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DestHostname($str) {
		CkSshTunnel_get_DestHostname($this->_cPtr,$str);
	}

	function destHostname() {
		return CkSshTunnel_destHostname($this->_cPtr);
	}

	function put_DestHostname($newVal) {
		CkSshTunnel_put_DestHostname($this->_cPtr,$newVal);
	}

	function get_DestPort() {
		return CkSshTunnel_get_DestPort($this->_cPtr);
	}

	function put_DestPort($newVal) {
		CkSshTunnel_put_DestPort($this->_cPtr,$newVal);
	}

	function get_DynamicPortForwarding() {
		return CkSshTunnel_get_DynamicPortForwarding($this->_cPtr);
	}

	function put_DynamicPortForwarding($newVal) {
		CkSshTunnel_put_DynamicPortForwarding($this->_cPtr,$newVal);
	}

	function get_HostKeyFingerprint($str) {
		CkSshTunnel_get_HostKeyFingerprint($this->_cPtr,$str);
	}

	function hostKeyFingerprint() {
		return CkSshTunnel_hostKeyFingerprint($this->_cPtr);
	}

	function get_HttpProxyAuthMethod($str) {
		CkSshTunnel_get_HttpProxyAuthMethod($this->_cPtr,$str);
	}

	function httpProxyAuthMethod() {
		return CkSshTunnel_httpProxyAuthMethod($this->_cPtr);
	}

	function put_HttpProxyAuthMethod($newVal) {
		CkSshTunnel_put_HttpProxyAuthMethod($this->_cPtr,$newVal);
	}

	function get_HttpProxyDomain($str) {
		CkSshTunnel_get_HttpProxyDomain($this->_cPtr,$str);
	}

	function httpProxyDomain() {
		return CkSshTunnel_httpProxyDomain($this->_cPtr);
	}

	function put_HttpProxyDomain($newVal) {
		CkSshTunnel_put_HttpProxyDomain($this->_cPtr,$newVal);
	}

	function get_HttpProxyHostname($str) {
		CkSshTunnel_get_HttpProxyHostname($this->_cPtr,$str);
	}

	function httpProxyHostname() {
		return CkSshTunnel_httpProxyHostname($this->_cPtr);
	}

	function put_HttpProxyHostname($newVal) {
		CkSshTunnel_put_HttpProxyHostname($this->_cPtr,$newVal);
	}

	function get_HttpProxyPassword($str) {
		CkSshTunnel_get_HttpProxyPassword($this->_cPtr,$str);
	}

	function httpProxyPassword() {
		return CkSshTunnel_httpProxyPassword($this->_cPtr);
	}

	function put_HttpProxyPassword($newVal) {
		CkSshTunnel_put_HttpProxyPassword($this->_cPtr,$newVal);
	}

	function get_HttpProxyPort() {
		return CkSshTunnel_get_HttpProxyPort($this->_cPtr);
	}

	function put_HttpProxyPort($newVal) {
		CkSshTunnel_put_HttpProxyPort($this->_cPtr,$newVal);
	}

	function get_HttpProxyUsername($str) {
		CkSshTunnel_get_HttpProxyUsername($this->_cPtr,$str);
	}

	function httpProxyUsername() {
		return CkSshTunnel_httpProxyUsername($this->_cPtr);
	}

	function put_HttpProxyUsername($newVal) {
		CkSshTunnel_put_HttpProxyUsername($this->_cPtr,$newVal);
	}

	function get_IdleTimeoutMs() {
		return CkSshTunnel_get_IdleTimeoutMs($this->_cPtr);
	}

	function put_IdleTimeoutMs($newVal) {
		CkSshTunnel_put_IdleTimeoutMs($this->_cPtr,$newVal);
	}

	function get_InboundSocksPassword($str) {
		CkSshTunnel_get_InboundSocksPassword($this->_cPtr,$str);
	}

	function inboundSocksPassword() {
		return CkSshTunnel_inboundSocksPassword($this->_cPtr);
	}

	function put_InboundSocksPassword($newVal) {
		CkSshTunnel_put_InboundSocksPassword($this->_cPtr,$newVal);
	}

	function get_InboundSocksUsername($str) {
		CkSshTunnel_get_InboundSocksUsername($this->_cPtr,$str);
	}

	function inboundSocksUsername() {
		return CkSshTunnel_inboundSocksUsername($this->_cPtr);
	}

	function put_InboundSocksUsername($newVal) {
		CkSshTunnel_put_InboundSocksUsername($this->_cPtr,$newVal);
	}

	function get_IsAccepting() {
		return CkSshTunnel_get_IsAccepting($this->_cPtr);
	}

	function get_KeepAcceptLog() {
		return CkSshTunnel_get_KeepAcceptLog($this->_cPtr);
	}

	function put_KeepAcceptLog($newVal) {
		CkSshTunnel_put_KeepAcceptLog($this->_cPtr,$newVal);
	}

	function get_KeepTunnelLog() {
		return CkSshTunnel_get_KeepTunnelLog($this->_cPtr);
	}

	function put_KeepTunnelLog($newVal) {
		CkSshTunnel_put_KeepTunnelLog($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkSshTunnel_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkSshTunnel_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkSshTunnel_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkSshTunnel_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkSshTunnel_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkSshTunnel_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkSshTunnel_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkSshTunnel_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_ListenBindIpAddress($str) {
		CkSshTunnel_get_ListenBindIpAddress($this->_cPtr,$str);
	}

	function listenBindIpAddress() {
		return CkSshTunnel_listenBindIpAddress($this->_cPtr);
	}

	function put_ListenBindIpAddress($newVal) {
		CkSshTunnel_put_ListenBindIpAddress($this->_cPtr,$newVal);
	}

	function get_ListenPort() {
		return CkSshTunnel_get_ListenPort($this->_cPtr);
	}

	function get_OutboundBindIpAddress($str) {
		CkSshTunnel_get_OutboundBindIpAddress($this->_cPtr,$str);
	}

	function outboundBindIpAddress() {
		return CkSshTunnel_outboundBindIpAddress($this->_cPtr);
	}

	function put_OutboundBindIpAddress($newVal) {
		CkSshTunnel_put_OutboundBindIpAddress($this->_cPtr,$newVal);
	}

	function get_OutboundBindPort() {
		return CkSshTunnel_get_OutboundBindPort($this->_cPtr);
	}

	function put_OutboundBindPort($newVal) {
		CkSshTunnel_put_OutboundBindPort($this->_cPtr,$newVal);
	}

	function get_PreferIpv6() {
		return CkSshTunnel_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkSshTunnel_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_SocksHostname($str) {
		CkSshTunnel_get_SocksHostname($this->_cPtr,$str);
	}

	function socksHostname() {
		return CkSshTunnel_socksHostname($this->_cPtr);
	}

	function put_SocksHostname($newVal) {
		CkSshTunnel_put_SocksHostname($this->_cPtr,$newVal);
	}

	function get_SocksPassword($str) {
		CkSshTunnel_get_SocksPassword($this->_cPtr,$str);
	}

	function socksPassword() {
		return CkSshTunnel_socksPassword($this->_cPtr);
	}

	function put_SocksPassword($newVal) {
		CkSshTunnel_put_SocksPassword($this->_cPtr,$newVal);
	}

	function get_SocksPort() {
		return CkSshTunnel_get_SocksPort($this->_cPtr);
	}

	function put_SocksPort($newVal) {
		CkSshTunnel_put_SocksPort($this->_cPtr,$newVal);
	}

	function get_SocksUsername($str) {
		CkSshTunnel_get_SocksUsername($this->_cPtr,$str);
	}

	function socksUsername() {
		return CkSshTunnel_socksUsername($this->_cPtr);
	}

	function put_SocksUsername($newVal) {
		CkSshTunnel_put_SocksUsername($this->_cPtr,$newVal);
	}

	function get_SocksVersion() {
		return CkSshTunnel_get_SocksVersion($this->_cPtr);
	}

	function put_SocksVersion($newVal) {
		CkSshTunnel_put_SocksVersion($this->_cPtr,$newVal);
	}

	function get_SoRcvBuf() {
		return CkSshTunnel_get_SoRcvBuf($this->_cPtr);
	}

	function put_SoRcvBuf($newVal) {
		CkSshTunnel_put_SoRcvBuf($this->_cPtr,$newVal);
	}

	function get_SoSndBuf() {
		return CkSshTunnel_get_SoSndBuf($this->_cPtr);
	}

	function put_SoSndBuf($newVal) {
		CkSshTunnel_put_SoSndBuf($this->_cPtr,$newVal);
	}

	function get_TcpNoDelay() {
		return CkSshTunnel_get_TcpNoDelay($this->_cPtr);
	}

	function put_TcpNoDelay($newVal) {
		CkSshTunnel_put_TcpNoDelay($this->_cPtr,$newVal);
	}

	function get_TunnelLog($str) {
		CkSshTunnel_get_TunnelLog($this->_cPtr,$str);
	}

	function tunnelLog() {
		return CkSshTunnel_tunnelLog($this->_cPtr);
	}

	function put_TunnelLog($newVal) {
		CkSshTunnel_put_TunnelLog($this->_cPtr,$newVal);
	}

	function get_TunnelLogPath($str) {
		CkSshTunnel_get_TunnelLogPath($this->_cPtr,$str);
	}

	function tunnelLogPath() {
		return CkSshTunnel_tunnelLogPath($this->_cPtr);
	}

	function put_TunnelLogPath($newVal) {
		CkSshTunnel_put_TunnelLogPath($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkSshTunnel_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkSshTunnel_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkSshTunnel_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkSshTunnel_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkSshTunnel_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkSshTunnel_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkSshTunnel_version($this->_cPtr);
	}

	function AuthenticatePk($username,$privateKey) {
		return CkSshTunnel_AuthenticatePk($this->_cPtr,$username,$privateKey);
	}

	function AuthenticatePkAsync($username,$privateKey) {
		$r=CkSshTunnel_AuthenticatePkAsync($this->_cPtr,$username,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticatePw($login,$password) {
		return CkSshTunnel_AuthenticatePw($this->_cPtr,$login,$password);
	}

	function AuthenticatePwAsync($login,$password) {
		$r=CkSshTunnel_AuthenticatePwAsync($this->_cPtr,$login,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticatePwPk($username,$password,$privateKey) {
		return CkSshTunnel_AuthenticatePwPk($this->_cPtr,$username,$password,$privateKey);
	}

	function AuthenticatePwPkAsync($username,$password,$privateKey) {
		$r=CkSshTunnel_AuthenticatePwPkAsync($this->_cPtr,$username,$password,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticateSecPw($login,$password) {
		return CkSshTunnel_AuthenticateSecPw($this->_cPtr,$login,$password);
	}

	function AuthenticateSecPwAsync($login,$password) {
		$r=CkSshTunnel_AuthenticateSecPwAsync($this->_cPtr,$login,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AuthenticateSecPwPk($username,$password,$privateKey) {
		return CkSshTunnel_AuthenticateSecPwPk($this->_cPtr,$username,$password,$privateKey);
	}

	function AuthenticateSecPwPkAsync($username,$password,$privateKey) {
		$r=CkSshTunnel_AuthenticateSecPwPkAsync($this->_cPtr,$username,$password,$privateKey);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function BeginAccepting($listenPort) {
		return CkSshTunnel_BeginAccepting($this->_cPtr,$listenPort);
	}

	function BeginAcceptingAsync($listenPort) {
		$r=CkSshTunnel_BeginAcceptingAsync($this->_cPtr,$listenPort);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CloseTunnel($waitForThreads) {
		return CkSshTunnel_CloseTunnel($this->_cPtr,$waitForThreads);
	}

	function Connect($hostname,$port) {
		return CkSshTunnel_Connect($this->_cPtr,$hostname,$port);
	}

	function ConnectAsync($hostname,$port) {
		$r=CkSshTunnel_ConnectAsync($this->_cPtr,$hostname,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ConnectThroughSsh($ssh,$hostname,$port) {
		return CkSshTunnel_ConnectThroughSsh($this->_cPtr,$ssh,$hostname,$port);
	}

	function ConnectThroughSshAsync($ssh,$hostname,$port) {
		$r=CkSshTunnel_ConnectThroughSshAsync($this->_cPtr,$ssh,$hostname,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function continueKeyboardAuth($response) {
		return CkSshTunnel_continueKeyboardAuth($this->_cPtr,$response);
	}

	function ContinueKeyboardAuthAsync($response) {
		$r=CkSshTunnel_ContinueKeyboardAuthAsync($this->_cPtr,$response);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function DisconnectAllClients($waitForThreads) {
		return CkSshTunnel_DisconnectAllClients($this->_cPtr,$waitForThreads);
	}

	function getCurrentState() {
		return CkSshTunnel_getCurrentState($this->_cPtr);
	}

	function currentState() {
		return CkSshTunnel_currentState($this->_cPtr);
	}

	function IsSshConnected() {
		return CkSshTunnel_IsSshConnected($this->_cPtr);
	}

	function LoadTaskCaller($task) {
		return CkSshTunnel_LoadTaskCaller($this->_cPtr,$task);
	}

	function SetAllowedAlgorithms($json) {
		return CkSshTunnel_SetAllowedAlgorithms($this->_cPtr,$json);
	}

	function startKeyboardAuth($login) {
		return CkSshTunnel_startKeyboardAuth($this->_cPtr,$login);
	}

	function StartKeyboardAuthAsync($login) {
		$r=CkSshTunnel_StartKeyboardAuthAsync($this->_cPtr,$login);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function StopAccepting($waitForThread) {
		return CkSshTunnel_StopAccepting($this->_cPtr,$waitForThread);
	}
}

class CkStream {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkStream') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkStream();
	}

	function get_Utf8() {
		return CkStream_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkStream_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkStream_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkStream_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkStream_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_CanRead() {
		return CkStream_get_CanRead($this->_cPtr);
	}

	function get_CanWrite() {
		return CkStream_get_CanWrite($this->_cPtr);
	}

	function get_DataAvailable() {
		return CkStream_get_DataAvailable($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkStream_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkStream_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkStream_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DefaultChunkSize() {
		return CkStream_get_DefaultChunkSize($this->_cPtr);
	}

	function put_DefaultChunkSize($newVal) {
		CkStream_put_DefaultChunkSize($this->_cPtr,$newVal);
	}

	function get_EndOfStream() {
		return CkStream_get_EndOfStream($this->_cPtr);
	}

	function get_HeartbeatMs() {
		return CkStream_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkStream_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_IsWriteClosed() {
		return CkStream_get_IsWriteClosed($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkStream_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkStream_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkStream_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkStream_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkStream_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkStream_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkStream_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkStream_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Length() {
		return CkStream_get_Length($this->_cPtr);
	}

	function put_Length($newVal) {
		CkStream_put_Length($this->_cPtr,$newVal);
	}

	function get_Length32() {
		return CkStream_get_Length32($this->_cPtr);
	}

	function put_Length32($newVal) {
		CkStream_put_Length32($this->_cPtr,$newVal);
	}

	function get_NumReceived() {
		return CkStream_get_NumReceived($this->_cPtr);
	}

	function get_NumSent() {
		return CkStream_get_NumSent($this->_cPtr);
	}

	function get_ReadFailReason() {
		return CkStream_get_ReadFailReason($this->_cPtr);
	}

	function get_ReadTimeoutMs() {
		return CkStream_get_ReadTimeoutMs($this->_cPtr);
	}

	function put_ReadTimeoutMs($newVal) {
		CkStream_put_ReadTimeoutMs($this->_cPtr,$newVal);
	}

	function get_SinkFile($str) {
		CkStream_get_SinkFile($this->_cPtr,$str);
	}

	function sinkFile() {
		return CkStream_sinkFile($this->_cPtr);
	}

	function put_SinkFile($newVal) {
		CkStream_put_SinkFile($this->_cPtr,$newVal);
	}

	function get_SinkFileAppend() {
		return CkStream_get_SinkFileAppend($this->_cPtr);
	}

	function put_SinkFileAppend($newVal) {
		CkStream_put_SinkFileAppend($this->_cPtr,$newVal);
	}

	function get_SourceFile($str) {
		CkStream_get_SourceFile($this->_cPtr,$str);
	}

	function sourceFile() {
		return CkStream_sourceFile($this->_cPtr);
	}

	function put_SourceFile($newVal) {
		CkStream_put_SourceFile($this->_cPtr,$newVal);
	}

	function get_SourceFilePart() {
		return CkStream_get_SourceFilePart($this->_cPtr);
	}

	function put_SourceFilePart($newVal) {
		CkStream_put_SourceFilePart($this->_cPtr,$newVal);
	}

	function get_SourceFilePartSize() {
		return CkStream_get_SourceFilePartSize($this->_cPtr);
	}

	function put_SourceFilePartSize($newVal) {
		CkStream_put_SourceFilePartSize($this->_cPtr,$newVal);
	}

	function get_StringBom() {
		return CkStream_get_StringBom($this->_cPtr);
	}

	function put_StringBom($newVal) {
		CkStream_put_StringBom($this->_cPtr,$newVal);
	}

	function get_StringCharset($str) {
		CkStream_get_StringCharset($this->_cPtr,$str);
	}

	function stringCharset() {
		return CkStream_stringCharset($this->_cPtr);
	}

	function put_StringCharset($newVal) {
		CkStream_put_StringCharset($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkStream_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkStream_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkStream_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkStream_version($this->_cPtr);
	}

	function get_WriteFailReason() {
		return CkStream_get_WriteFailReason($this->_cPtr);
	}

	function get_WriteTimeoutMs() {
		return CkStream_get_WriteTimeoutMs($this->_cPtr);
	}

	function put_WriteTimeoutMs($newVal) {
		CkStream_put_WriteTimeoutMs($this->_cPtr,$newVal);
	}

	function LoadTaskCaller($task) {
		return CkStream_LoadTaskCaller($this->_cPtr,$task);
	}

	function ReadBd($binData) {
		return CkStream_ReadBd($this->_cPtr,$binData);
	}

	function ReadBdAsync($binData) {
		$r=CkStream_ReadBdAsync($this->_cPtr,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadBytes($outBytes) {
		return CkStream_ReadBytes($this->_cPtr,$outBytes);
	}

	function ReadBytesAsync() {
		$r=CkStream_ReadBytesAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function readBytesENC($encoding) {
		return CkStream_readBytesENC($this->_cPtr,$encoding);
	}

	function ReadBytesENCAsync($encoding) {
		$r=CkStream_ReadBytesENCAsync($this->_cPtr,$encoding);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadNBytes($numBytes,$outBytes) {
		return CkStream_ReadNBytes($this->_cPtr,$numBytes,$outBytes);
	}

	function ReadNBytesAsync($numBytes) {
		$r=CkStream_ReadNBytesAsync($this->_cPtr,$numBytes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function readNBytesENC($numBytes,$encoding) {
		return CkStream_readNBytesENC($this->_cPtr,$numBytes,$encoding);
	}

	function ReadNBytesENCAsync($numBytes,$encoding) {
		$r=CkStream_ReadNBytesENCAsync($this->_cPtr,$numBytes,$encoding);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ReadSb($sb) {
		return CkStream_ReadSb($this->_cPtr,$sb);
	}

	function ReadSbAsync($sb) {
		$r=CkStream_ReadSbAsync($this->_cPtr,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function readString() {
		return CkStream_readString($this->_cPtr);
	}

	function ReadStringAsync() {
		$r=CkStream_ReadStringAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function readToCRLF() {
		return CkStream_readToCRLF($this->_cPtr);
	}

	function ReadToCRLFAsync() {
		$r=CkStream_ReadToCRLFAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function readUntilMatch($matchStr) {
		return CkStream_readUntilMatch($this->_cPtr,$matchStr);
	}

	function ReadUntilMatchAsync($matchStr) {
		$r=CkStream_ReadUntilMatchAsync($this->_cPtr,$matchStr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Reset() {
		CkStream_Reset($this->_cPtr);
	}

	function SetSourceBytes($sourceData) {
		return CkStream_SetSourceBytes($this->_cPtr,$sourceData);
	}

	function SetSourceString($srcStr,$charset) {
		return CkStream_SetSourceString($this->_cPtr,$srcStr,$charset);
	}

	function WriteBd($binData) {
		return CkStream_WriteBd($this->_cPtr,$binData);
	}

	function WriteBdAsync($binData) {
		$r=CkStream_WriteBdAsync($this->_cPtr,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteByte($byteVal) {
		return CkStream_WriteByte($this->_cPtr,$byteVal);
	}

	function WriteByteAsync($byteVal) {
		$r=CkStream_WriteByteAsync($this->_cPtr,$byteVal);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteBytes($byteData) {
		return CkStream_WriteBytes($this->_cPtr,$byteData);
	}

	function WriteBytesAsync($byteData) {
		$r=CkStream_WriteBytesAsync($this->_cPtr,$byteData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteBytesENC($byteData,$encoding) {
		return CkStream_WriteBytesENC($this->_cPtr,$byteData,$encoding);
	}

	function WriteBytesENCAsync($byteData,$encoding) {
		$r=CkStream_WriteBytesENCAsync($this->_cPtr,$byteData,$encoding);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteClose() {
		return CkStream_WriteClose($this->_cPtr);
	}

	function WriteSb($sb) {
		return CkStream_WriteSb($this->_cPtr,$sb);
	}

	function WriteSbAsync($sb) {
		$r=CkStream_WriteSbAsync($this->_cPtr,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteString($str) {
		return CkStream_WriteString($this->_cPtr,$str);
	}

	function WriteStringAsync($str) {
		$r=CkStream_WriteStringAsync($this->_cPtr,$str);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkStringArray {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkStringArray') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkStringArray();
	}

	function get_Utf8() {
		return CkStringArray_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkStringArray_put_Utf8($this->_cPtr,$b);
	}

	function get_Count() {
		return CkStringArray_get_Count($this->_cPtr);
	}

	function get_Crlf() {
		return CkStringArray_get_Crlf($this->_cPtr);
	}

	function put_Crlf($newVal) {
		CkStringArray_put_Crlf($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkStringArray_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkStringArray_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkStringArray_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkStringArray_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkStringArray_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkStringArray_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkStringArray_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkStringArray_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkStringArray_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkStringArray_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkStringArray_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Length() {
		return CkStringArray_get_Length($this->_cPtr);
	}

	function get_Trim() {
		return CkStringArray_get_Trim($this->_cPtr);
	}

	function put_Trim($newVal) {
		CkStringArray_put_Trim($this->_cPtr,$newVal);
	}

	function get_Unique() {
		return CkStringArray_get_Unique($this->_cPtr);
	}

	function put_Unique($newVal) {
		CkStringArray_put_Unique($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkStringArray_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkStringArray_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkStringArray_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkStringArray_version($this->_cPtr);
	}

	function Append($str) {
		return CkStringArray_Append($this->_cPtr,$str);
	}

	function AppendSerialized($encodedStr) {
		return CkStringArray_AppendSerialized($this->_cPtr,$encodedStr);
	}

	function Clear() {
		CkStringArray_Clear($this->_cPtr);
	}

	function Contains($str) {
		return CkStringArray_Contains($this->_cPtr,$str);
	}

	function Find($findStr,$startIndex) {
		return CkStringArray_Find($this->_cPtr,$findStr,$startIndex);
	}

	function FindFirstMatch($matchPattern,$startIndex) {
		return CkStringArray_FindFirstMatch($this->_cPtr,$matchPattern,$startIndex);
	}

	function getString($index) {
		return CkStringArray_getString($this->_cPtr,$index);
	}

	function string($index) {
		return CkStringArray_string($this->_cPtr,$index);
	}

	function GetStringLen($index) {
		return CkStringArray_GetStringLen($this->_cPtr,$index);
	}

	function InsertAt($index,$str) {
		CkStringArray_InsertAt($this->_cPtr,$index,$str);
	}

	function lastString() {
		return CkStringArray_lastString($this->_cPtr);
	}

	function LoadFromFile($path) {
		return CkStringArray_LoadFromFile($this->_cPtr,$path);
	}

	function LoadFromFile2($path,$charset) {
		return CkStringArray_LoadFromFile2($this->_cPtr,$path,$charset);
	}

	function LoadFromText($str) {
		CkStringArray_LoadFromText($this->_cPtr,$str);
	}

	function LoadTaskResult($task) {
		return CkStringArray_LoadTaskResult($this->_cPtr,$task);
	}

	function pop() {
		return CkStringArray_pop($this->_cPtr);
	}

	function Prepend($str) {
		CkStringArray_Prepend($this->_cPtr,$str);
	}

	function Remove($str) {
		CkStringArray_Remove($this->_cPtr,$str);
	}

	function RemoveAt($index) {
		return CkStringArray_RemoveAt($this->_cPtr,$index);
	}

	function ReplaceAt($index,$str) {
		CkStringArray_ReplaceAt($this->_cPtr,$index,$str);
	}

	function SaveNthToFile($index,$saveToPath) {
		return CkStringArray_SaveNthToFile($this->_cPtr,$index,$saveToPath);
	}

	function SaveToFile($path) {
		return CkStringArray_SaveToFile($this->_cPtr,$path);
	}

	function SaveToFile2($saveToPath,$charset) {
		return CkStringArray_SaveToFile2($this->_cPtr,$saveToPath,$charset);
	}

	function saveToText() {
		return CkStringArray_saveToText($this->_cPtr);
	}

	function serialize() {
		return CkStringArray_serialize($this->_cPtr);
	}

	function Sort($ascending) {
		CkStringArray_Sort($this->_cPtr,$ascending);
	}

	function SplitAndAppend($str,$boundary) {
		CkStringArray_SplitAndAppend($this->_cPtr,$str,$boundary);
	}

	function strAt($index) {
		return CkStringArray_strAt($this->_cPtr,$index);
	}

	function Subtract($stringArrayObj) {
		CkStringArray_Subtract($this->_cPtr,$stringArrayObj);
	}

	function Union($stringArrayObj) {
		CkStringArray_Union($this->_cPtr,$stringArrayObj);
	}
}

class CkStringBuilder {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkStringBuilder') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkStringBuilder();
	}

	function get_Utf8() {
		return CkStringBuilder_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkStringBuilder_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkStringBuilder_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkStringBuilder_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkStringBuilder_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_HasEmojis() {
		return CkStringBuilder_get_HasEmojis($this->_cPtr);
	}

	function get_IntValue() {
		return CkStringBuilder_get_IntValue($this->_cPtr);
	}

	function put_IntValue($newVal) {
		CkStringBuilder_put_IntValue($this->_cPtr,$newVal);
	}

	function get_IsBase64() {
		return CkStringBuilder_get_IsBase64($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkStringBuilder_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkStringBuilder_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkStringBuilder_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkStringBuilder_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkStringBuilder_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkStringBuilder_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkStringBuilder_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkStringBuilder_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Length() {
		return CkStringBuilder_get_Length($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkStringBuilder_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkStringBuilder_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkStringBuilder_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkStringBuilder_version($this->_cPtr);
	}

	function Append($value) {
		return CkStringBuilder_Append($this->_cPtr,$value);
	}

	function AppendBd($binData,$charset,$offset,$numBytes) {
		return CkStringBuilder_AppendBd($this->_cPtr,$binData,$charset,$offset,$numBytes);
	}

	function AppendEncoded($binaryData,$encoding) {
		return CkStringBuilder_AppendEncoded($this->_cPtr,$binaryData,$encoding);
	}

	function AppendInt($value) {
		return CkStringBuilder_AppendInt($this->_cPtr,$value);
	}

	function AppendLine($value,$crlf) {
		return CkStringBuilder_AppendLine($this->_cPtr,$value,$crlf);
	}

	function AppendRandom($numBytes,$encoding) {
		return CkStringBuilder_AppendRandom($this->_cPtr,$numBytes,$encoding);
	}

	function AppendSb($sb) {
		return CkStringBuilder_AppendSb($this->_cPtr,$sb);
	}

	function AppendUuid($lowerCase) {
		return CkStringBuilder_AppendUuid($this->_cPtr,$lowerCase);
	}

	function AppendUuid7($lowerCase) {
		return CkStringBuilder_AppendUuid7($this->_cPtr,$lowerCase);
	}

	function Clear() {
		CkStringBuilder_Clear($this->_cPtr);
	}

	function Contains($str,$caseSensitive) {
		return CkStringBuilder_Contains($this->_cPtr,$str,$caseSensitive);
	}

	function ContainsWord($word,$caseSensitive) {
		return CkStringBuilder_ContainsWord($this->_cPtr,$word,$caseSensitive);
	}

	function ContentsEqual($str,$caseSensitive) {
		return CkStringBuilder_ContentsEqual($this->_cPtr,$str,$caseSensitive);
	}

	function ContentsEqualSb($sb,$caseSensitive) {
		return CkStringBuilder_ContentsEqualSb($this->_cPtr,$sb,$caseSensitive);
	}

	function Decode($encoding,$charset) {
		return CkStringBuilder_Decode($this->_cPtr,$encoding,$charset);
	}

	function DecodeAndAppend($value,$encoding,$charset) {
		return CkStringBuilder_DecodeAndAppend($this->_cPtr,$value,$encoding,$charset);
	}

	function Encode($encoding,$charset) {
		return CkStringBuilder_Encode($this->_cPtr,$encoding,$charset);
	}

	function EndsWith($substr,$caseSensitive) {
		return CkStringBuilder_EndsWith($this->_cPtr,$substr,$caseSensitive);
	}

	function EntityDecode() {
		return CkStringBuilder_EntityDecode($this->_cPtr);
	}

	function getAfterBetween($searchAfter,$beginMark,$endMark) {
		return CkStringBuilder_getAfterBetween($this->_cPtr,$searchAfter,$beginMark,$endMark);
	}

	function afterBetween($searchAfter,$beginMark,$endMark) {
		return CkStringBuilder_afterBetween($this->_cPtr,$searchAfter,$beginMark,$endMark);
	}

	function getAfterFinal($marker,$removeFlag) {
		return CkStringBuilder_getAfterFinal($this->_cPtr,$marker,$removeFlag);
	}

	function afterFinal($marker,$removeFlag) {
		return CkStringBuilder_afterFinal($this->_cPtr,$marker,$removeFlag);
	}

	function getAsString() {
		return CkStringBuilder_getAsString($this->_cPtr);
	}

	function asString() {
		return CkStringBuilder_asString($this->_cPtr);
	}

	function getBefore($marker,$removeFlag) {
		return CkStringBuilder_getBefore($this->_cPtr,$marker,$removeFlag);
	}

	function before($marker,$removeFlag) {
		return CkStringBuilder_before($this->_cPtr,$marker,$removeFlag);
	}

	function getBetween($beginMark,$endMark) {
		return CkStringBuilder_getBetween($this->_cPtr,$beginMark,$endMark);
	}

	function between($beginMark,$endMark) {
		return CkStringBuilder_between($this->_cPtr,$beginMark,$endMark);
	}

	function GetDecoded($encoding,$outBytes) {
		return CkStringBuilder_GetDecoded($this->_cPtr,$encoding,$outBytes);
	}

	function getEncoded($encoding,$charset) {
		return CkStringBuilder_getEncoded($this->_cPtr,$encoding,$charset);
	}

	function encoded($encoding,$charset) {
		return CkStringBuilder_encoded($this->_cPtr,$encoding,$charset);
	}

	function getHash($algorithm,$encoding,$charset) {
		return CkStringBuilder_getHash($this->_cPtr,$algorithm,$encoding,$charset);
	}

	function hash($algorithm,$encoding,$charset) {
		return CkStringBuilder_hash($this->_cPtr,$algorithm,$encoding,$charset);
	}

	function getNth($index,$delimiterChar,$exceptDoubleQuoted,$exceptEscaped) {
		return CkStringBuilder_getNth($this->_cPtr,$index,$delimiterChar,$exceptDoubleQuoted,$exceptEscaped);
	}

	function nth($index,$delimiterChar,$exceptDoubleQuoted,$exceptEscaped) {
		return CkStringBuilder_nth($this->_cPtr,$index,$delimiterChar,$exceptDoubleQuoted,$exceptEscaped);
	}

	function getRange($startIndex,$numChars,$removeFlag) {
		return CkStringBuilder_getRange($this->_cPtr,$startIndex,$numChars,$removeFlag);
	}

	function range($startIndex,$numChars,$removeFlag) {
		return CkStringBuilder_range($this->_cPtr,$startIndex,$numChars,$removeFlag);
	}

	function GetRangeSb($startIndex,$numChars,$removeFlag,$sb) {
		return CkStringBuilder_GetRangeSb($this->_cPtr,$startIndex,$numChars,$removeFlag,$sb);
	}

	function lastNLines($numLines,$bCrlf) {
		return CkStringBuilder_lastNLines($this->_cPtr,$numLines,$bCrlf);
	}

	function LoadFile($path,$charset) {
		return CkStringBuilder_LoadFile($this->_cPtr,$path,$charset);
	}

	function MarkdownToHtml($options,$sbHtml) {
		return CkStringBuilder_MarkdownToHtml($this->_cPtr,$options,$sbHtml);
	}

	function MaskQuotedStrings($maskChar,$quoteType,$maskedStrings) {
		return CkStringBuilder_MaskQuotedStrings($this->_cPtr,$maskChar,$quoteType,$maskedStrings);
	}

	function Obfuscate() {
		CkStringBuilder_Obfuscate($this->_cPtr);
	}

	function Prepend($value) {
		return CkStringBuilder_Prepend($this->_cPtr,$value);
	}

	function PunyDecode() {
		return CkStringBuilder_PunyDecode($this->_cPtr);
	}

	function PunyEncode() {
		return CkStringBuilder_PunyEncode($this->_cPtr);
	}

	function RegexMatch($pattern,$json,$timeoutMs) {
		return CkStringBuilder_RegexMatch($this->_cPtr,$pattern,$json,$timeoutMs);
	}

	function RegexReplace($json) {
		return CkStringBuilder_RegexReplace($this->_cPtr,$json);
	}

	function RemoveAccents() {
		return CkStringBuilder_RemoveAccents($this->_cPtr);
	}

	function RemoveAfterFinal($marker) {
		return CkStringBuilder_RemoveAfterFinal($this->_cPtr,$marker);
	}

	function RemoveBefore($marker) {
		return CkStringBuilder_RemoveBefore($this->_cPtr,$marker);
	}

	function RemoveCharsAt($startIndex,$numChars) {
		return CkStringBuilder_RemoveCharsAt($this->_cPtr,$startIndex,$numChars);
	}

	function RemoveEmojis() {
		CkStringBuilder_RemoveEmojis($this->_cPtr);
	}

	function Replace($value,$replacement) {
		return CkStringBuilder_Replace($this->_cPtr,$value,$replacement);
	}

	function ReplaceAfterFinal($marker,$replacement) {
		return CkStringBuilder_ReplaceAfterFinal($this->_cPtr,$marker,$replacement);
	}

	function ReplaceAllBetween($beginMark,$endMark,$replacement,$replaceMarks) {
		return CkStringBuilder_ReplaceAllBetween($this->_cPtr,$beginMark,$endMark,$replacement,$replaceMarks);
	}

	function ReplaceBetween($beginMark,$endMark,$value,$replacement) {
		return CkStringBuilder_ReplaceBetween($this->_cPtr,$beginMark,$endMark,$value,$replacement);
	}

	function ReplaceFirst($value,$replacement) {
		return CkStringBuilder_ReplaceFirst($this->_cPtr,$value,$replacement);
	}

	function ReplaceI($value,$replacement) {
		return CkStringBuilder_ReplaceI($this->_cPtr,$value,$replacement);
	}

	function ReplaceNoCase($value,$replacement) {
		return CkStringBuilder_ReplaceNoCase($this->_cPtr,$value,$replacement);
	}

	function ReplaceWord($value,$replacement) {
		return CkStringBuilder_ReplaceWord($this->_cPtr,$value,$replacement);
	}

	function RestoreMaskedStrings($quoteType,$maskedStrings) {
		return CkStringBuilder_RestoreMaskedStrings($this->_cPtr,$quoteType,$maskedStrings);
	}

	function SecureClear() {
		CkStringBuilder_SecureClear($this->_cPtr);
	}

	function SetNth($index,$value,$delimiterChar,$exceptDoubleQuoted,$exceptEscaped) {
		return CkStringBuilder_SetNth($this->_cPtr,$index,$value,$delimiterChar,$exceptDoubleQuoted,$exceptEscaped);
	}

	function SetString($value) {
		return CkStringBuilder_SetString($this->_cPtr,$value);
	}

	function Shorten($numChars) {
		return CkStringBuilder_Shorten($this->_cPtr,$numChars);
	}

	function StartsWith($substr,$caseSensitive) {
		return CkStringBuilder_StartsWith($this->_cPtr,$substr,$caseSensitive);
	}

	function ToCRLF() {
		return CkStringBuilder_ToCRLF($this->_cPtr);
	}

	function ToLF() {
		return CkStringBuilder_ToLF($this->_cPtr);
	}

	function ToLowercase() {
		return CkStringBuilder_ToLowercase($this->_cPtr);
	}

	function ToUppercase() {
		return CkStringBuilder_ToUppercase($this->_cPtr);
	}

	function Trim() {
		return CkStringBuilder_Trim($this->_cPtr);
	}

	function TrimInsideSpaces() {
		return CkStringBuilder_TrimInsideSpaces($this->_cPtr);
	}

	function Unobfuscate() {
		CkStringBuilder_Unobfuscate($this->_cPtr);
	}

	function WriteFile($path,$charset,$emitBom) {
		return CkStringBuilder_WriteFile($this->_cPtr,$path,$charset,$emitBom);
	}

	function WriteFileIfModified($path,$charset,$emitBom) {
		return CkStringBuilder_WriteFileIfModified($this->_cPtr,$path,$charset,$emitBom);
	}
}

class CkStringTable {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkStringTable') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkStringTable();
	}

	function get_Utf8() {
		return CkStringTable_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkStringTable_put_Utf8($this->_cPtr,$b);
	}

	function get_Count() {
		return CkStringTable_get_Count($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkStringTable_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkStringTable_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkStringTable_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkStringTable_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkStringTable_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkStringTable_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkStringTable_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkStringTable_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkStringTable_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkStringTable_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkStringTable_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkStringTable_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkStringTable_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkStringTable_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkStringTable_version($this->_cPtr);
	}

	function Append($value) {
		return CkStringTable_Append($this->_cPtr,$value);
	}

	function AppendFromFile($maxLineLen,$charset,$path) {
		return CkStringTable_AppendFromFile($this->_cPtr,$maxLineLen,$charset,$path);
	}

	function AppendFromSb($sb) {
		return CkStringTable_AppendFromSb($this->_cPtr,$sb);
	}

	function Clear() {
		CkStringTable_Clear($this->_cPtr);
	}

	function FindMatch($sb,$caseSensitive) {
		return CkStringTable_FindMatch($this->_cPtr,$sb,$caseSensitive);
	}

	function FindSubstring($startIndex,$substr,$caseSensitive) {
		return CkStringTable_FindSubstring($this->_cPtr,$startIndex,$substr,$caseSensitive);
	}

	function getStrings($startIdx,$count,$crlf) {
		return CkStringTable_getStrings($this->_cPtr,$startIdx,$count,$crlf);
	}

	function strings($startIdx,$count,$crlf) {
		return CkStringTable_strings($this->_cPtr,$startIdx,$count,$crlf);
	}

	function IntAt($index) {
		return CkStringTable_IntAt($this->_cPtr,$index);
	}

	function SaveToFile($charset,$bCrlf,$path) {
		return CkStringTable_SaveToFile($this->_cPtr,$charset,$bCrlf,$path);
	}

	function Sort($ascending,$caseSensitive) {
		return CkStringTable_Sort($this->_cPtr,$ascending,$caseSensitive);
	}

	function SplitAndAppend($inStr,$delimiterChar,$exceptDoubleQuoted,$exceptEscaped) {
		return CkStringTable_SplitAndAppend($this->_cPtr,$inStr,$delimiterChar,$exceptDoubleQuoted,$exceptEscaped);
	}

	function stringAt($index) {
		return CkStringTable_stringAt($this->_cPtr,$index);
	}

	function StringAtSb($index,$sb) {
		return CkStringTable_StringAtSb($this->_cPtr,$index,$sb);
	}

	function ToSb($sb) {
		return CkStringTable_ToSb($this->_cPtr,$sb);
	}

	function WordFollowing($sb,$captureEmailAddr,$sbWord) {
		return CkStringTable_WordFollowing($this->_cPtr,$sb,$captureEmailAddr,$sbWord);
	}
}

class CkTar {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkTar') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkTar();
	}

	function get_Utf8() {
		return CkTar_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkTar_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkTar_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_CaptureXmlListing() {
		return CkTar_get_CaptureXmlListing($this->_cPtr);
	}

	function put_CaptureXmlListing($newVal) {
		CkTar_put_CaptureXmlListing($this->_cPtr,$newVal);
	}

	function get_Charset($str) {
		CkTar_get_Charset($this->_cPtr,$str);
	}

	function charset() {
		return CkTar_charset($this->_cPtr);
	}

	function put_Charset($newVal) {
		CkTar_put_Charset($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkTar_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkTar_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkTar_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DirMode() {
		return CkTar_get_DirMode($this->_cPtr);
	}

	function put_DirMode($newVal) {
		CkTar_put_DirMode($this->_cPtr,$newVal);
	}

	function get_DirPrefix($str) {
		CkTar_get_DirPrefix($this->_cPtr,$str);
	}

	function dirPrefix() {
		return CkTar_dirPrefix($this->_cPtr);
	}

	function put_DirPrefix($newVal) {
		CkTar_put_DirPrefix($this->_cPtr,$newVal);
	}

	function get_FileMode() {
		return CkTar_get_FileMode($this->_cPtr);
	}

	function put_FileMode($newVal) {
		CkTar_put_FileMode($this->_cPtr,$newVal);
	}

	function get_GroupId() {
		return CkTar_get_GroupId($this->_cPtr);
	}

	function put_GroupId($newVal) {
		CkTar_put_GroupId($this->_cPtr,$newVal);
	}

	function get_GroupName($str) {
		CkTar_get_GroupName($this->_cPtr,$str);
	}

	function groupName() {
		return CkTar_groupName($this->_cPtr);
	}

	function put_GroupName($newVal) {
		CkTar_put_GroupName($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkTar_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkTar_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkTar_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkTar_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkTar_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkTar_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkTar_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkTar_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkTar_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkTar_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_MatchCaseSensitive() {
		return CkTar_get_MatchCaseSensitive($this->_cPtr);
	}

	function put_MatchCaseSensitive($newVal) {
		CkTar_put_MatchCaseSensitive($this->_cPtr,$newVal);
	}

	function get_MustMatch($str) {
		CkTar_get_MustMatch($this->_cPtr,$str);
	}

	function mustMatch() {
		return CkTar_mustMatch($this->_cPtr);
	}

	function put_MustMatch($newVal) {
		CkTar_put_MustMatch($this->_cPtr,$newVal);
	}

	function get_MustNotMatch($str) {
		CkTar_get_MustNotMatch($this->_cPtr,$str);
	}

	function mustNotMatch() {
		return CkTar_mustNotMatch($this->_cPtr);
	}

	function put_MustNotMatch($newVal) {
		CkTar_put_MustNotMatch($this->_cPtr,$newVal);
	}

	function get_NoAbsolutePaths() {
		return CkTar_get_NoAbsolutePaths($this->_cPtr);
	}

	function put_NoAbsolutePaths($newVal) {
		CkTar_put_NoAbsolutePaths($this->_cPtr,$newVal);
	}

	function get_NumDirRoots() {
		return CkTar_get_NumDirRoots($this->_cPtr);
	}

	function get_PercentDoneScale() {
		return CkTar_get_PercentDoneScale($this->_cPtr);
	}

	function put_PercentDoneScale($newVal) {
		CkTar_put_PercentDoneScale($this->_cPtr,$newVal);
	}

	function get_ScriptFileMode() {
		return CkTar_get_ScriptFileMode($this->_cPtr);
	}

	function put_ScriptFileMode($newVal) {
		CkTar_put_ScriptFileMode($this->_cPtr,$newVal);
	}

	function get_SuppressOutput() {
		return CkTar_get_SuppressOutput($this->_cPtr);
	}

	function put_SuppressOutput($newVal) {
		CkTar_put_SuppressOutput($this->_cPtr,$newVal);
	}

	function get_UntarCaseSensitive() {
		return CkTar_get_UntarCaseSensitive($this->_cPtr);
	}

	function put_UntarCaseSensitive($newVal) {
		CkTar_put_UntarCaseSensitive($this->_cPtr,$newVal);
	}

	function get_UntarDebugLog() {
		return CkTar_get_UntarDebugLog($this->_cPtr);
	}

	function put_UntarDebugLog($newVal) {
		CkTar_put_UntarDebugLog($this->_cPtr,$newVal);
	}

	function get_UntarDiscardPaths() {
		return CkTar_get_UntarDiscardPaths($this->_cPtr);
	}

	function put_UntarDiscardPaths($newVal) {
		CkTar_put_UntarDiscardPaths($this->_cPtr,$newVal);
	}

	function get_UntarFromDir($str) {
		CkTar_get_UntarFromDir($this->_cPtr,$str);
	}

	function untarFromDir() {
		return CkTar_untarFromDir($this->_cPtr);
	}

	function put_UntarFromDir($newVal) {
		CkTar_put_UntarFromDir($this->_cPtr,$newVal);
	}

	function get_UntarMaxCount() {
		return CkTar_get_UntarMaxCount($this->_cPtr);
	}

	function put_UntarMaxCount($newVal) {
		CkTar_put_UntarMaxCount($this->_cPtr,$newVal);
	}

	function get_UserId() {
		return CkTar_get_UserId($this->_cPtr);
	}

	function put_UserId($newVal) {
		CkTar_put_UserId($this->_cPtr,$newVal);
	}

	function get_UserName($str) {
		CkTar_get_UserName($this->_cPtr,$str);
	}

	function userName() {
		return CkTar_userName($this->_cPtr);
	}

	function put_UserName($newVal) {
		CkTar_put_UserName($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkTar_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkTar_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkTar_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkTar_version($this->_cPtr);
	}

	function get_WriteFormat($str) {
		CkTar_get_WriteFormat($this->_cPtr,$str);
	}

	function writeFormat() {
		return CkTar_writeFormat($this->_cPtr);
	}

	function put_WriteFormat($newVal) {
		CkTar_put_WriteFormat($this->_cPtr,$newVal);
	}

	function get_XmlListing($str) {
		CkTar_get_XmlListing($this->_cPtr,$str);
	}

	function xmlListing() {
		return CkTar_xmlListing($this->_cPtr);
	}

	function put_XmlListing($newVal) {
		CkTar_put_XmlListing($this->_cPtr,$newVal);
	}

	function AddDirRoot($dirPath) {
		return CkTar_AddDirRoot($this->_cPtr,$dirPath);
	}

	function AddDirRoot2($rootPrefix,$rootPath) {
		return CkTar_AddDirRoot2($this->_cPtr,$rootPrefix,$rootPath);
	}

	function AddFile($path) {
		return CkTar_AddFile($this->_cPtr,$path);
	}

	function AddFile2($filePath,$pathWithinTar) {
		return CkTar_AddFile2($this->_cPtr,$filePath,$pathWithinTar);
	}

	function ClearDirRootsAndFiles() {
		return CkTar_ClearDirRootsAndFiles($this->_cPtr);
	}

	function CreateDeb($controlPath,$dataPath,$debPath) {
		return CkTar_CreateDeb($this->_cPtr,$controlPath,$dataPath,$debPath);
	}

	function getDirRoot($index) {
		return CkTar_getDirRoot($this->_cPtr,$index);
	}

	function dirRoot($index) {
		return CkTar_dirRoot($this->_cPtr,$index);
	}

	function listXml($tarPath) {
		return CkTar_listXml($this->_cPtr,$tarPath);
	}

	function ListXmlAsync($tarPath) {
		$r=CkTar_ListXmlAsync($this->_cPtr,$tarPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkTar_LoadTaskCaller($this->_cPtr,$task);
	}

	function Untar($tarPath) {
		return CkTar_Untar($this->_cPtr,$tarPath);
	}

	function UntarAsync($tarPath) {
		$r=CkTar_UntarAsync($this->_cPtr,$tarPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UntarBz2($tarPath) {
		return CkTar_UntarBz2($this->_cPtr,$tarPath);
	}

	function UntarBz2Async($tarPath) {
		$r=CkTar_UntarBz2Async($this->_cPtr,$tarPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UntarFirstMatchingToBd($tarPath,$matchPattern,$bd) {
		return CkTar_UntarFirstMatchingToBd($this->_cPtr,$tarPath,$matchPattern,$bd);
	}

	function UntarFirstMatchingToMemory($tarFileBytes,$matchPattern,$outBytes) {
		return CkTar_UntarFirstMatchingToMemory($this->_cPtr,$tarFileBytes,$matchPattern,$outBytes);
	}

	function UntarFromMemory($tarFileBytes) {
		return CkTar_UntarFromMemory($this->_cPtr,$tarFileBytes);
	}

	function UntarFromMemoryAsync($tarFileBytes) {
		$r=CkTar_UntarFromMemoryAsync($this->_cPtr,$tarFileBytes);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UntarGz($tarPath) {
		return CkTar_UntarGz($this->_cPtr,$tarPath);
	}

	function UntarGzAsync($tarPath) {
		$r=CkTar_UntarGzAsync($this->_cPtr,$tarPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UntarZ($tarPath) {
		return CkTar_UntarZ($this->_cPtr,$tarPath);
	}

	function UntarZAsync($tarPath) {
		$r=CkTar_UntarZAsync($this->_cPtr,$tarPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function VerifyTar($tarPath) {
		return CkTar_VerifyTar($this->_cPtr,$tarPath);
	}

	function VerifyTarAsync($tarPath) {
		$r=CkTar_VerifyTarAsync($this->_cPtr,$tarPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteTar($tarPath) {
		return CkTar_WriteTar($this->_cPtr,$tarPath);
	}

	function WriteTarAsync($tarPath) {
		$r=CkTar_WriteTarAsync($this->_cPtr,$tarPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteTarBz2($bz2Path) {
		return CkTar_WriteTarBz2($this->_cPtr,$bz2Path);
	}

	function WriteTarBz2Async($bz2Path) {
		$r=CkTar_WriteTarBz2Async($this->_cPtr,$bz2Path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteTarGz($gzPath) {
		return CkTar_WriteTarGz($this->_cPtr,$gzPath);
	}

	function WriteTarGzAsync($gzPath) {
		$r=CkTar_WriteTarGzAsync($this->_cPtr,$gzPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkTask {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkTask') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkTask();
	}

	function get_Utf8() {
		return CkTask_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkTask_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkTask_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_DebugLogFilePath($str) {
		CkTask_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkTask_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkTask_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Finished() {
		return CkTask_get_Finished($this->_cPtr);
	}

	function get_HeartbeatMs() {
		return CkTask_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkTask_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_Inert() {
		return CkTask_get_Inert($this->_cPtr);
	}

	function get_KeepProgressLog() {
		return CkTask_get_KeepProgressLog($this->_cPtr);
	}

	function put_KeepProgressLog($newVal) {
		CkTask_put_KeepProgressLog($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkTask_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkTask_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkTask_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkTask_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkTask_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkTask_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkTask_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkTask_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Live() {
		return CkTask_get_Live($this->_cPtr);
	}

	function get_PercentDone() {
		return CkTask_get_PercentDone($this->_cPtr);
	}

	function get_ProgressLogSize() {
		return CkTask_get_ProgressLogSize($this->_cPtr);
	}

	function get_ResultErrorText($str) {
		CkTask_get_ResultErrorText($this->_cPtr,$str);
	}

	function resultErrorText() {
		return CkTask_resultErrorText($this->_cPtr);
	}

	function get_ResultType($str) {
		CkTask_get_ResultType($this->_cPtr,$str);
	}

	function resultType() {
		return CkTask_resultType($this->_cPtr);
	}

	function get_Status($str) {
		CkTask_get_Status($this->_cPtr,$str);
	}

	function status() {
		return CkTask_status($this->_cPtr);
	}

	function get_StatusInt() {
		return CkTask_get_StatusInt($this->_cPtr);
	}

	function get_TaskId() {
		return CkTask_get_TaskId($this->_cPtr);
	}

	function get_TaskSuccess() {
		return CkTask_get_TaskSuccess($this->_cPtr);
	}

	function get_UserData($str) {
		CkTask_get_UserData($this->_cPtr,$str);
	}

	function userData() {
		return CkTask_userData($this->_cPtr);
	}

	function put_UserData($newVal) {
		CkTask_put_UserData($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkTask_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkTask_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkTask_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkTask_version($this->_cPtr);
	}

	function Cancel() {
		return CkTask_Cancel($this->_cPtr);
	}

	function ClearProgressLog() {
		CkTask_ClearProgressLog($this->_cPtr);
	}

	function CopyResultBytes($outBytes) {
		return CkTask_CopyResultBytes($this->_cPtr,$outBytes);
	}

	function GetResultBool() {
		return CkTask_GetResultBool($this->_cPtr);
	}

	function GetResultBytes($outBytes) {
		return CkTask_GetResultBytes($this->_cPtr,$outBytes);
	}

	function GetResultInt() {
		return CkTask_GetResultInt($this->_cPtr);
	}

	function getResultString() {
		return CkTask_getResultString($this->_cPtr);
	}

	function resultString() {
		return CkTask_resultString($this->_cPtr);
	}

	function progressInfoName($index) {
		return CkTask_progressInfoName($this->_cPtr,$index);
	}

	function progressInfoValue($index) {
		return CkTask_progressInfoValue($this->_cPtr,$index);
	}

	function RemoveProgressInfo($index) {
		CkTask_RemoveProgressInfo($this->_cPtr,$index);
	}

	function Run() {
		return CkTask_Run($this->_cPtr);
	}

	function RunSynchronously() {
		return CkTask_RunSynchronously($this->_cPtr);
	}

	function SleepMs($numMs) {
		CkTask_SleepMs($this->_cPtr,$numMs);
	}

	function Wait($maxWaitMs) {
		return CkTask_Wait($this->_cPtr,$maxWaitMs);
	}
}

class CkTaskChain {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkTaskChain') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkTaskChain();
	}

	function get_Utf8() {
		return CkTaskChain_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkTaskChain_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkTaskChain_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_DebugLogFilePath($str) {
		CkTaskChain_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkTaskChain_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkTaskChain_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Finished() {
		return CkTaskChain_get_Finished($this->_cPtr);
	}

	function get_HeartbeatMs() {
		return CkTaskChain_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkTaskChain_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_Inert() {
		return CkTaskChain_get_Inert($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkTaskChain_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkTaskChain_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkTaskChain_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkTaskChain_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkTaskChain_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkTaskChain_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkTaskChain_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkTaskChain_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Live() {
		return CkTaskChain_get_Live($this->_cPtr);
	}

	function get_NumTasks() {
		return CkTaskChain_get_NumTasks($this->_cPtr);
	}

	function get_Status($str) {
		CkTaskChain_get_Status($this->_cPtr,$str);
	}

	function status() {
		return CkTaskChain_status($this->_cPtr);
	}

	function get_StatusInt() {
		return CkTaskChain_get_StatusInt($this->_cPtr);
	}

	function get_StopOnFailedTask() {
		return CkTaskChain_get_StopOnFailedTask($this->_cPtr);
	}

	function put_StopOnFailedTask($newVal) {
		CkTaskChain_put_StopOnFailedTask($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkTaskChain_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkTaskChain_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkTaskChain_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkTaskChain_version($this->_cPtr);
	}

	function Append($task) {
		return CkTaskChain_Append($this->_cPtr,$task);
	}

	function Cancel() {
		return CkTaskChain_Cancel($this->_cPtr);
	}

	function GetTask($index) {
		$r=CkTaskChain_GetTask($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Run() {
		return CkTaskChain_Run($this->_cPtr);
	}

	function RunSynchronously() {
		return CkTaskChain_RunSynchronously($this->_cPtr);
	}

	function SleepMs($numMs) {
		CkTaskChain_SleepMs($this->_cPtr,$numMs);
	}

	function Wait($maxWaitMs) {
		return CkTaskChain_Wait($this->_cPtr,$maxWaitMs);
	}
}

class CkTrustedRoots {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkTrustedRoots') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkTrustedRoots();
	}

	function get_Utf8() {
		return CkTrustedRoots_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkTrustedRoots_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkTrustedRoots_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_DebugLogFilePath($str) {
		CkTrustedRoots_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkTrustedRoots_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkTrustedRoots_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkTrustedRoots_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkTrustedRoots_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkTrustedRoots_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkTrustedRoots_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkTrustedRoots_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkTrustedRoots_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkTrustedRoots_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkTrustedRoots_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumCerts() {
		return CkTrustedRoots_get_NumCerts($this->_cPtr);
	}

	function get_RejectSelfSignedCerts() {
		return CkTrustedRoots_get_RejectSelfSignedCerts($this->_cPtr);
	}

	function put_RejectSelfSignedCerts($newVal) {
		CkTrustedRoots_put_RejectSelfSignedCerts($this->_cPtr,$newVal);
	}

	function get_TrustSystemCaRoots() {
		return CkTrustedRoots_get_TrustSystemCaRoots($this->_cPtr);
	}

	function put_TrustSystemCaRoots($newVal) {
		CkTrustedRoots_put_TrustSystemCaRoots($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkTrustedRoots_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkTrustedRoots_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkTrustedRoots_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkTrustedRoots_version($this->_cPtr);
	}

	function Activate() {
		return CkTrustedRoots_Activate($this->_cPtr);
	}

	function AddCert($cert) {
		return CkTrustedRoots_AddCert($this->_cPtr,$cert);
	}

	function AddJavaKeyStore($keystore) {
		return CkTrustedRoots_AddJavaKeyStore($this->_cPtr,$keystore);
	}

	function AddJavaKeyStoreAsync($keystore) {
		$r=CkTrustedRoots_AddJavaKeyStoreAsync($this->_cPtr,$keystore);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CertAt($index,$cert) {
		return CkTrustedRoots_CertAt($this->_cPtr,$index,$cert);
	}

	function Deactivate() {
		return CkTrustedRoots_Deactivate($this->_cPtr);
	}

	function GetCert($index) {
		$r=CkTrustedRoots_GetCert($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkCert($r);
		}
		return $r;
	}

	function LoadCaCertsPem($path) {
		return CkTrustedRoots_LoadCaCertsPem($this->_cPtr,$path);
	}

	function LoadCaCertsPemAsync($path) {
		$r=CkTrustedRoots_LoadCaCertsPemAsync($this->_cPtr,$path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkTrustedRoots_LoadTaskCaller($this->_cPtr,$task);
	}
}

class CkUnixCompress {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkUnixCompress') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkUnixCompress();
	}

	function get_Utf8() {
		return CkUnixCompress_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkUnixCompress_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkUnixCompress_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkUnixCompress_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkUnixCompress_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkUnixCompress_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkUnixCompress_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkUnixCompress_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkUnixCompress_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkUnixCompress_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkUnixCompress_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkUnixCompress_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkUnixCompress_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkUnixCompress_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkUnixCompress_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkUnixCompress_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkUnixCompress_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkUnixCompress_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkUnixCompress_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkUnixCompress_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkUnixCompress_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkUnixCompress_version($this->_cPtr);
	}

	function CompressFile($inFilename,$destPath) {
		return CkUnixCompress_CompressFile($this->_cPtr,$inFilename,$destPath);
	}

	function CompressFileAsync($inFilename,$destPath) {
		$r=CkUnixCompress_CompressFileAsync($this->_cPtr,$inFilename,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressFileToMem($inFilename,$outData) {
		return CkUnixCompress_CompressFileToMem($this->_cPtr,$inFilename,$outData);
	}

	function CompressFileToMemAsync($inFilename) {
		$r=CkUnixCompress_CompressFileToMemAsync($this->_cPtr,$inFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CompressMemory($inData,$outData) {
		return CkUnixCompress_CompressMemory($this->_cPtr,$inData,$outData);
	}

	function CompressMemToFile($inData,$destPath) {
		return CkUnixCompress_CompressMemToFile($this->_cPtr,$inData,$destPath);
	}

	function CompressString($inStr,$charset,$outBytes) {
		return CkUnixCompress_CompressString($this->_cPtr,$inStr,$charset,$outBytes);
	}

	function CompressStringToFile($inStr,$charset,$destPath) {
		return CkUnixCompress_CompressStringToFile($this->_cPtr,$inStr,$charset,$destPath);
	}

	function LoadTaskCaller($task) {
		return CkUnixCompress_LoadTaskCaller($this->_cPtr,$task);
	}

	function UncompressFile($inFilename,$destPath) {
		return CkUnixCompress_UncompressFile($this->_cPtr,$inFilename,$destPath);
	}

	function UncompressFileAsync($inFilename,$destPath) {
		$r=CkUnixCompress_UncompressFileAsync($this->_cPtr,$inFilename,$destPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressFileToMem($inFilename,$outData) {
		return CkUnixCompress_UncompressFileToMem($this->_cPtr,$inFilename,$outData);
	}

	function UncompressFileToMemAsync($inFilename) {
		$r=CkUnixCompress_UncompressFileToMemAsync($this->_cPtr,$inFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function uncompressFileToString($zFilename,$charset) {
		return CkUnixCompress_uncompressFileToString($this->_cPtr,$zFilename,$charset);
	}

	function UncompressFileToStringAsync($zFilename,$charset) {
		$r=CkUnixCompress_UncompressFileToStringAsync($this->_cPtr,$zFilename,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UncompressMemory($inData,$outData) {
		return CkUnixCompress_UncompressMemory($this->_cPtr,$inData,$outData);
	}

	function UncompressMemToFile($inData,$destPath) {
		return CkUnixCompress_UncompressMemToFile($this->_cPtr,$inData,$destPath);
	}

	function uncompressString($inCompressedData,$charset) {
		return CkUnixCompress_uncompressString($this->_cPtr,$inCompressedData,$charset);
	}

	function UnTarZ($zFilename,$destDir,$bNoAbsolute) {
		return CkUnixCompress_UnTarZ($this->_cPtr,$zFilename,$destDir,$bNoAbsolute);
	}

	function UnTarZAsync($zFilename,$destDir,$bNoAbsolute) {
		$r=CkUnixCompress_UnTarZAsync($this->_cPtr,$zFilename,$destDir,$bNoAbsolute);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkUpload {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkUpload') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkUpload();
	}

	function get_Utf8() {
		return CkUpload_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkUpload_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkUpload_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkUpload_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkUpload_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_BandwidthThrottleUp() {
		return CkUpload_get_BandwidthThrottleUp($this->_cPtr);
	}

	function put_BandwidthThrottleUp($newVal) {
		CkUpload_put_BandwidthThrottleUp($this->_cPtr,$newVal);
	}

	function get_ChunkSize() {
		return CkUpload_get_ChunkSize($this->_cPtr);
	}

	function put_ChunkSize($newVal) {
		CkUpload_put_ChunkSize($this->_cPtr,$newVal);
	}

	function get_ClientIpAddress($str) {
		CkUpload_get_ClientIpAddress($this->_cPtr,$str);
	}

	function clientIpAddress() {
		return CkUpload_clientIpAddress($this->_cPtr);
	}

	function put_ClientIpAddress($newVal) {
		CkUpload_put_ClientIpAddress($this->_cPtr,$newVal);
	}

	function get_CurrentFilename($str) {
		CkUpload_get_CurrentFilename($this->_cPtr,$str);
	}

	function currentFilename() {
		return CkUpload_currentFilename($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkUpload_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkUpload_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkUpload_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Expect100Continue() {
		return CkUpload_get_Expect100Continue($this->_cPtr);
	}

	function put_Expect100Continue($newVal) {
		CkUpload_put_Expect100Continue($this->_cPtr,$newVal);
	}

	function get_HeartbeatMs() {
		return CkUpload_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkUpload_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_Hostname($str) {
		CkUpload_get_Hostname($this->_cPtr,$str);
	}

	function hostname() {
		return CkUpload_hostname($this->_cPtr);
	}

	function put_Hostname($newVal) {
		CkUpload_put_Hostname($this->_cPtr,$newVal);
	}

	function get_IdleTimeoutMs() {
		return CkUpload_get_IdleTimeoutMs($this->_cPtr);
	}

	function put_IdleTimeoutMs($newVal) {
		CkUpload_put_IdleTimeoutMs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkUpload_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkUpload_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkUpload_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkUpload_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkUpload_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkUpload_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkUpload_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkUpload_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Login($str) {
		CkUpload_get_Login($this->_cPtr,$str);
	}

	function login() {
		return CkUpload_login($this->_cPtr);
	}

	function put_Login($newVal) {
		CkUpload_put_Login($this->_cPtr,$newVal);
	}

	function get_NumBytesSent() {
		return CkUpload_get_NumBytesSent($this->_cPtr);
	}

	function get_Password($str) {
		CkUpload_get_Password($this->_cPtr,$str);
	}

	function password() {
		return CkUpload_password($this->_cPtr);
	}

	function put_Password($newVal) {
		CkUpload_put_Password($this->_cPtr,$newVal);
	}

	function get_Path($str) {
		CkUpload_get_Path($this->_cPtr,$str);
	}

	function path() {
		return CkUpload_path($this->_cPtr);
	}

	function put_Path($newVal) {
		CkUpload_put_Path($this->_cPtr,$newVal);
	}

	function get_PercentDoneScale() {
		return CkUpload_get_PercentDoneScale($this->_cPtr);
	}

	function put_PercentDoneScale($newVal) {
		CkUpload_put_PercentDoneScale($this->_cPtr,$newVal);
	}

	function get_PercentUploaded() {
		return CkUpload_get_PercentUploaded($this->_cPtr);
	}

	function get_Port() {
		return CkUpload_get_Port($this->_cPtr);
	}

	function put_Port($newVal) {
		CkUpload_put_Port($this->_cPtr,$newVal);
	}

	function get_PreferIpv6() {
		return CkUpload_get_PreferIpv6($this->_cPtr);
	}

	function put_PreferIpv6($newVal) {
		CkUpload_put_PreferIpv6($this->_cPtr,$newVal);
	}

	function get_ProxyDomain($str) {
		CkUpload_get_ProxyDomain($this->_cPtr,$str);
	}

	function proxyDomain() {
		return CkUpload_proxyDomain($this->_cPtr);
	}

	function put_ProxyDomain($newVal) {
		CkUpload_put_ProxyDomain($this->_cPtr,$newVal);
	}

	function get_ProxyLogin($str) {
		CkUpload_get_ProxyLogin($this->_cPtr,$str);
	}

	function proxyLogin() {
		return CkUpload_proxyLogin($this->_cPtr);
	}

	function put_ProxyLogin($newVal) {
		CkUpload_put_ProxyLogin($this->_cPtr,$newVal);
	}

	function get_ProxyPassword($str) {
		CkUpload_get_ProxyPassword($this->_cPtr,$str);
	}

	function proxyPassword() {
		return CkUpload_proxyPassword($this->_cPtr);
	}

	function put_ProxyPassword($newVal) {
		CkUpload_put_ProxyPassword($this->_cPtr,$newVal);
	}

	function get_ProxyPort() {
		return CkUpload_get_ProxyPort($this->_cPtr);
	}

	function put_ProxyPort($newVal) {
		CkUpload_put_ProxyPort($this->_cPtr,$newVal);
	}

	function get_ResponseBodyStr($str) {
		CkUpload_get_ResponseBodyStr($this->_cPtr,$str);
	}

	function responseBodyStr() {
		return CkUpload_responseBodyStr($this->_cPtr);
	}

	function get_ResponseHeader($str) {
		CkUpload_get_ResponseHeader($this->_cPtr,$str);
	}

	function responseHeader() {
		return CkUpload_responseHeader($this->_cPtr);
	}

	function get_ResponseStatus() {
		return CkUpload_get_ResponseStatus($this->_cPtr);
	}

	function get_Ssl() {
		return CkUpload_get_Ssl($this->_cPtr);
	}

	function put_Ssl($newVal) {
		CkUpload_put_Ssl($this->_cPtr,$newVal);
	}

	function get_SslAllowedCiphers($str) {
		CkUpload_get_SslAllowedCiphers($this->_cPtr,$str);
	}

	function sslAllowedCiphers() {
		return CkUpload_sslAllowedCiphers($this->_cPtr);
	}

	function put_SslAllowedCiphers($newVal) {
		CkUpload_put_SslAllowedCiphers($this->_cPtr,$newVal);
	}

	function get_SslProtocol($str) {
		CkUpload_get_SslProtocol($this->_cPtr,$str);
	}

	function sslProtocol() {
		return CkUpload_sslProtocol($this->_cPtr);
	}

	function put_SslProtocol($newVal) {
		CkUpload_put_SslProtocol($this->_cPtr,$newVal);
	}

	function get_TlsPinSet($str) {
		CkUpload_get_TlsPinSet($this->_cPtr,$str);
	}

	function tlsPinSet() {
		return CkUpload_tlsPinSet($this->_cPtr);
	}

	function put_TlsPinSet($newVal) {
		CkUpload_put_TlsPinSet($this->_cPtr,$newVal);
	}

	function get_TotalUploadSize() {
		return CkUpload_get_TotalUploadSize($this->_cPtr);
	}

	function get_UploadInProgress() {
		return CkUpload_get_UploadInProgress($this->_cPtr);
	}

	function get_UploadSuccess() {
		return CkUpload_get_UploadSuccess($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkUpload_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkUpload_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkUpload_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkUpload_version($this->_cPtr);
	}

	function AbortUpload() {
		CkUpload_AbortUpload($this->_cPtr);
	}

	function AddCustomHeader($name,$value) {
		CkUpload_AddCustomHeader($this->_cPtr,$name,$value);
	}

	function AddFileReference($name,$filename) {
		CkUpload_AddFileReference($this->_cPtr,$name,$filename);
	}

	function AddParam($name,$value) {
		CkUpload_AddParam($this->_cPtr,$name,$value);
	}

	function BeginUpload() {
		return CkUpload_BeginUpload($this->_cPtr);
	}

	function BlockingUpload() {
		return CkUpload_BlockingUpload($this->_cPtr);
	}

	function BlockingUploadAsync() {
		$r=CkUpload_BlockingUploadAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ClearFileReferences() {
		CkUpload_ClearFileReferences($this->_cPtr);
	}

	function ClearParams() {
		CkUpload_ClearParams($this->_cPtr);
	}

	function LoadTaskCaller($task) {
		return CkUpload_LoadTaskCaller($this->_cPtr,$task);
	}

	function SleepMs($millisec) {
		CkUpload_SleepMs($this->_cPtr,$millisec);
	}

	function UploadToMemory($outData) {
		return CkUpload_UploadToMemory($this->_cPtr,$outData);
	}
}

class CkUrl {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkUrl') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkUrl();
	}

	function get_Utf8() {
		return CkUrl_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkUrl_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkUrl_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkUrl_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkUrl_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_Frag($str) {
		CkUrl_get_Frag($this->_cPtr,$str);
	}

	function frag() {
		return CkUrl_frag($this->_cPtr);
	}

	function get_Host($str) {
		CkUrl_get_Host($this->_cPtr,$str);
	}

	function host() {
		return CkUrl_host($this->_cPtr);
	}

	function get_HostType($str) {
		CkUrl_get_HostType($this->_cPtr,$str);
	}

	function hostType() {
		return CkUrl_hostType($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkUrl_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkUrl_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkUrl_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkUrl_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkUrl_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkUrl_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkUrl_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkUrl_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_Login($str) {
		CkUrl_get_Login($this->_cPtr,$str);
	}

	function login() {
		return CkUrl_login($this->_cPtr);
	}

	function get_Password($str) {
		CkUrl_get_Password($this->_cPtr,$str);
	}

	function password() {
		return CkUrl_password($this->_cPtr);
	}

	function get_Path($str) {
		CkUrl_get_Path($this->_cPtr,$str);
	}

	function path() {
		return CkUrl_path($this->_cPtr);
	}

	function get_PathWithQueryParams($str) {
		CkUrl_get_PathWithQueryParams($this->_cPtr,$str);
	}

	function pathWithQueryParams() {
		return CkUrl_pathWithQueryParams($this->_cPtr);
	}

	function get_Port() {
		return CkUrl_get_Port($this->_cPtr);
	}

	function get_Query($str) {
		CkUrl_get_Query($this->_cPtr,$str);
	}

	function query() {
		return CkUrl_query($this->_cPtr);
	}

	function get_Ssl() {
		return CkUrl_get_Ssl($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkUrl_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkUrl_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkUrl_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkUrl_version($this->_cPtr);
	}

	function ParseUrl($url) {
		return CkUrl_ParseUrl($this->_cPtr,$url);
	}
}

class CkWebSocket {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkWebSocket') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkWebSocket();
	}

	function get_Utf8() {
		return CkWebSocket_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkWebSocket_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkWebSocket_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_CloseAutoRespond() {
		return CkWebSocket_get_CloseAutoRespond($this->_cPtr);
	}

	function put_CloseAutoRespond($newVal) {
		CkWebSocket_put_CloseAutoRespond($this->_cPtr,$newVal);
	}

	function get_CloseReason($str) {
		CkWebSocket_get_CloseReason($this->_cPtr,$str);
	}

	function closeReason() {
		return CkWebSocket_closeReason($this->_cPtr);
	}

	function get_CloseReceived() {
		return CkWebSocket_get_CloseReceived($this->_cPtr);
	}

	function get_CloseStatusCode() {
		return CkWebSocket_get_CloseStatusCode($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkWebSocket_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkWebSocket_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkWebSocket_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_FinalFrame() {
		return CkWebSocket_get_FinalFrame($this->_cPtr);
	}

	function get_FrameDataLen() {
		return CkWebSocket_get_FrameDataLen($this->_cPtr);
	}

	function get_FrameOpcode($str) {
		CkWebSocket_get_FrameOpcode($this->_cPtr,$str);
	}

	function frameOpcode() {
		return CkWebSocket_frameOpcode($this->_cPtr);
	}

	function get_FrameOpcodeInt() {
		return CkWebSocket_get_FrameOpcodeInt($this->_cPtr);
	}

	function get_HeartbeatMs() {
		return CkWebSocket_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkWebSocket_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_IdleTimeoutMs() {
		return CkWebSocket_get_IdleTimeoutMs($this->_cPtr);
	}

	function put_IdleTimeoutMs($newVal) {
		CkWebSocket_put_IdleTimeoutMs($this->_cPtr,$newVal);
	}

	function get_IsConnected() {
		return CkWebSocket_get_IsConnected($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkWebSocket_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkWebSocket_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkWebSocket_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkWebSocket_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkWebSocket_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkWebSocket_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkWebSocket_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkWebSocket_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NeedSendPong() {
		return CkWebSocket_get_NeedSendPong($this->_cPtr);
	}

	function get_PingAutoRespond() {
		return CkWebSocket_get_PingAutoRespond($this->_cPtr);
	}

	function put_PingAutoRespond($newVal) {
		CkWebSocket_put_PingAutoRespond($this->_cPtr,$newVal);
	}

	function get_PongAutoConsume() {
		return CkWebSocket_get_PongAutoConsume($this->_cPtr);
	}

	function put_PongAutoConsume($newVal) {
		CkWebSocket_put_PongAutoConsume($this->_cPtr,$newVal);
	}

	function get_PongConsumed() {
		return CkWebSocket_get_PongConsumed($this->_cPtr);
	}

	function get_ReadFrameFailReason() {
		return CkWebSocket_get_ReadFrameFailReason($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkWebSocket_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkWebSocket_uncommonOptions($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkWebSocket_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkWebSocket_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkWebSocket_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkWebSocket_version($this->_cPtr);
	}

	function AddClientHeaders() {
		return CkWebSocket_AddClientHeaders($this->_cPtr);
	}

	function CloseConnection() {
		return CkWebSocket_CloseConnection($this->_cPtr);
	}

	function getFrameData() {
		return CkWebSocket_getFrameData($this->_cPtr);
	}

	function frameData() {
		return CkWebSocket_frameData($this->_cPtr);
	}

	function GetFrameDataBd($binData) {
		return CkWebSocket_GetFrameDataBd($this->_cPtr,$binData);
	}

	function GetFrameDataSb($sb) {
		return CkWebSocket_GetFrameDataSb($this->_cPtr,$sb);
	}

	function LoadTaskCaller($task) {
		return CkWebSocket_LoadTaskCaller($this->_cPtr,$task);
	}

	function PollDataAvailable() {
		return CkWebSocket_PollDataAvailable($this->_cPtr);
	}

	function ReadFrame() {
		return CkWebSocket_ReadFrame($this->_cPtr);
	}

	function ReadFrameAsync() {
		$r=CkWebSocket_ReadFrameAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendClose($includeStatus,$statusCode,$reason) {
		return CkWebSocket_SendClose($this->_cPtr,$includeStatus,$statusCode,$reason);
	}

	function SendCloseAsync($includeStatus,$statusCode,$reason) {
		$r=CkWebSocket_SendCloseAsync($this->_cPtr,$includeStatus,$statusCode,$reason);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendFrame($stringToSend,$finalFrame) {
		return CkWebSocket_SendFrame($this->_cPtr,$stringToSend,$finalFrame);
	}

	function SendFrameAsync($stringToSend,$finalFrame) {
		$r=CkWebSocket_SendFrameAsync($this->_cPtr,$stringToSend,$finalFrame);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendFrameBd($bdToSend,$finalFrame) {
		return CkWebSocket_SendFrameBd($this->_cPtr,$bdToSend,$finalFrame);
	}

	function SendFrameBdAsync($bdToSend,$finalFrame) {
		$r=CkWebSocket_SendFrameBdAsync($this->_cPtr,$bdToSend,$finalFrame);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendFrameSb($sbToSend,$finalFrame) {
		return CkWebSocket_SendFrameSb($this->_cPtr,$sbToSend,$finalFrame);
	}

	function SendFrameSbAsync($sbToSend,$finalFrame) {
		$r=CkWebSocket_SendFrameSbAsync($this->_cPtr,$sbToSend,$finalFrame);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendPing($pingData) {
		return CkWebSocket_SendPing($this->_cPtr,$pingData);
	}

	function SendPingAsync($pingData) {
		$r=CkWebSocket_SendPingAsync($this->_cPtr,$pingData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SendPong() {
		return CkWebSocket_SendPong($this->_cPtr);
	}

	function SendPongAsync() {
		$r=CkWebSocket_SendPongAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ShareConnection($ws) {
		return CkWebSocket_ShareConnection($this->_cPtr,$ws);
	}

	function UseConnection($connection) {
		return CkWebSocket_UseConnection($this->_cPtr,$connection);
	}

	function ValidateServerHandshake() {
		return CkWebSocket_ValidateServerHandshake($this->_cPtr);
	}
}

class CkXml {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkXml') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkXml();
	}

	function get_Utf8() {
		return CkXml_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkXml_put_Utf8($this->_cPtr,$b);
	}

	function get_Cdata() {
		return CkXml_get_Cdata($this->_cPtr);
	}

	function put_Cdata($newVal) {
		CkXml_put_Cdata($this->_cPtr,$newVal);
	}

	function get_Content($str) {
		CkXml_get_Content($this->_cPtr,$str);
	}

	function content() {
		return CkXml_content($this->_cPtr);
	}

	function put_Content($newVal) {
		CkXml_put_Content($this->_cPtr,$newVal);
	}

	function get_ContentInt() {
		return CkXml_get_ContentInt($this->_cPtr);
	}

	function put_ContentInt($newVal) {
		CkXml_put_ContentInt($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkXml_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkXml_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkXml_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DocType($str) {
		CkXml_get_DocType($this->_cPtr,$str);
	}

	function docType() {
		return CkXml_docType($this->_cPtr);
	}

	function put_DocType($newVal) {
		CkXml_put_DocType($this->_cPtr,$newVal);
	}

	function get_EmitBom() {
		return CkXml_get_EmitBom($this->_cPtr);
	}

	function put_EmitBom($newVal) {
		CkXml_put_EmitBom($this->_cPtr,$newVal);
	}

	function get_EmitCompact() {
		return CkXml_get_EmitCompact($this->_cPtr);
	}

	function put_EmitCompact($newVal) {
		CkXml_put_EmitCompact($this->_cPtr,$newVal);
	}

	function get_EmitXmlDecl() {
		return CkXml_get_EmitXmlDecl($this->_cPtr);
	}

	function put_EmitXmlDecl($newVal) {
		CkXml_put_EmitXmlDecl($this->_cPtr,$newVal);
	}

	function get_Encoding($str) {
		CkXml_get_Encoding($this->_cPtr,$str);
	}

	function encoding() {
		return CkXml_encoding($this->_cPtr);
	}

	function put_Encoding($newVal) {
		CkXml_put_Encoding($this->_cPtr,$newVal);
	}

	function get_I() {
		return CkXml_get_I($this->_cPtr);
	}

	function put_I($newVal) {
		CkXml_put_I($this->_cPtr,$newVal);
	}

	function get_IsBase64() {
		return CkXml_get_IsBase64($this->_cPtr);
	}

	function get_J() {
		return CkXml_get_J($this->_cPtr);
	}

	function put_J($newVal) {
		CkXml_put_J($this->_cPtr,$newVal);
	}

	function get_K() {
		return CkXml_get_K($this->_cPtr);
	}

	function put_K($newVal) {
		CkXml_put_K($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkXml_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkXml_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkXml_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkXml_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkXml_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkXml_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkXml_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkXml_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumAttributes() {
		return CkXml_get_NumAttributes($this->_cPtr);
	}

	function get_NumChildren() {
		return CkXml_get_NumChildren($this->_cPtr);
	}

	function get_SortCaseInsensitive() {
		return CkXml_get_SortCaseInsensitive($this->_cPtr);
	}

	function put_SortCaseInsensitive($newVal) {
		CkXml_put_SortCaseInsensitive($this->_cPtr,$newVal);
	}

	function get_Standalone() {
		return CkXml_get_Standalone($this->_cPtr);
	}

	function put_Standalone($newVal) {
		CkXml_put_Standalone($this->_cPtr,$newVal);
	}

	function get_Tag($str) {
		CkXml_get_Tag($this->_cPtr,$str);
	}

	function tag() {
		return CkXml_tag($this->_cPtr);
	}

	function put_Tag($newVal) {
		CkXml_put_Tag($this->_cPtr,$newVal);
	}

	function get_TagNsPrefix($str) {
		CkXml_get_TagNsPrefix($this->_cPtr,$str);
	}

	function tagNsPrefix() {
		return CkXml_tagNsPrefix($this->_cPtr);
	}

	function put_TagNsPrefix($newVal) {
		CkXml_put_TagNsPrefix($this->_cPtr,$newVal);
	}

	function get_TagPath($str) {
		CkXml_get_TagPath($this->_cPtr,$str);
	}

	function tagPath() {
		return CkXml_tagPath($this->_cPtr);
	}

	function get_TagUnprefixed($str) {
		CkXml_get_TagUnprefixed($this->_cPtr,$str);
	}

	function tagUnprefixed() {
		return CkXml_tagUnprefixed($this->_cPtr);
	}

	function put_TagUnprefixed($newVal) {
		CkXml_put_TagUnprefixed($this->_cPtr,$newVal);
	}

	function get_TreeId() {
		return CkXml_get_TreeId($this->_cPtr);
	}

	function get_UncommonOptions($str) {
		CkXml_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkXml_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkXml_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkXml_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkXml_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkXml_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkXml_version($this->_cPtr);
	}

	function accumulateTagContent($tag,$skipTags) {
		return CkXml_accumulateTagContent($this->_cPtr,$tag,$skipTags);
	}

	function AddAttribute($name,$value) {
		return CkXml_AddAttribute($this->_cPtr,$name,$value);
	}

	function AddAttributeInt($name,$value) {
		return CkXml_AddAttributeInt($this->_cPtr,$name,$value);
	}

	function AddChildTree($tree) {
		return CkXml_AddChildTree($this->_cPtr,$tree);
	}

	function AddOrUpdateAttribute($name,$value) {
		CkXml_AddOrUpdateAttribute($this->_cPtr,$name,$value);
	}

	function AddOrUpdateAttributeI($name,$value) {
		CkXml_AddOrUpdateAttributeI($this->_cPtr,$name,$value);
	}

	function AddStyleSheet($styleSheet) {
		CkXml_AddStyleSheet($this->_cPtr,$styleSheet);
	}

	function AddToAttribute($name,$amount) {
		CkXml_AddToAttribute($this->_cPtr,$name,$amount);
	}

	function AddToChildContent($tag,$amount) {
		CkXml_AddToChildContent($this->_cPtr,$tag,$amount);
	}

	function AddToContent($amount) {
		CkXml_AddToContent($this->_cPtr,$amount);
	}

	function AppendToContent($str) {
		return CkXml_AppendToContent($this->_cPtr,$str);
	}

	function BEncodeContent($charset,$inData) {
		return CkXml_BEncodeContent($this->_cPtr,$charset,$inData);
	}

	function ChildContentMatches($tagPath,$pattern,$caseSensitive) {
		return CkXml_ChildContentMatches($this->_cPtr,$tagPath,$pattern,$caseSensitive);
	}

	function chilkatPath($pathCmd) {
		return CkXml_chilkatPath($this->_cPtr,$pathCmd);
	}

	function Clear() {
		CkXml_Clear($this->_cPtr);
	}

	function ContentMatches($pattern,$caseSensitive) {
		return CkXml_ContentMatches($this->_cPtr,$pattern,$caseSensitive);
	}

	function Copy($node) {
		CkXml_Copy($this->_cPtr,$node);
	}

	function CopyRef($copyFromNode) {
		CkXml_CopyRef($this->_cPtr,$copyFromNode);
	}

	function DecodeContent($outData) {
		return CkXml_DecodeContent($this->_cPtr,$outData);
	}

	function decodeEntities($str) {
		return CkXml_decodeEntities($this->_cPtr,$str);
	}

	function DecryptContent($password) {
		return CkXml_DecryptContent($this->_cPtr,$password);
	}

	function EncryptContent($password) {
		return CkXml_EncryptContent($this->_cPtr,$password);
	}

	function ExtractChildByIndex($index) {
		$r=CkXml_ExtractChildByIndex($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function ExtractChildByName($tagPath,$attrName,$attrValue) {
		$r=CkXml_ExtractChildByName($this->_cPtr,$tagPath,$attrName,$attrValue);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function FindChild($tagPath) {
		$r=CkXml_FindChild($this->_cPtr,$tagPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function FindChild2($tagPath) {
		return CkXml_FindChild2($this->_cPtr,$tagPath);
	}

	function FindNextRecord($tagPath,$contentPattern) {
		$r=CkXml_FindNextRecord($this->_cPtr,$tagPath,$contentPattern);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function FindOrAddNewChild($tagPath) {
		$r=CkXml_FindOrAddNewChild($this->_cPtr,$tagPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function FirstChild() {
		$r=CkXml_FirstChild($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function FirstChild2() {
		return CkXml_FirstChild2($this->_cPtr);
	}

	function getAttributeName($index) {
		return CkXml_getAttributeName($this->_cPtr,$index);
	}

	function attributeName($index) {
		return CkXml_attributeName($this->_cPtr,$index);
	}

	function getAttributeValue($index) {
		return CkXml_getAttributeValue($this->_cPtr,$index);
	}

	function attributeValue($index) {
		return CkXml_attributeValue($this->_cPtr,$index);
	}

	function GetAttributeValueInt($index) {
		return CkXml_GetAttributeValueInt($this->_cPtr,$index);
	}

	function getAttrValue($name) {
		return CkXml_getAttrValue($this->_cPtr,$name);
	}

	function attrValue($name) {
		return CkXml_attrValue($this->_cPtr,$name);
	}

	function GetAttrValueInt($name) {
		return CkXml_GetAttrValueInt($this->_cPtr,$name);
	}

	function GetBinaryContent($unzipFlag,$decryptFlag,$password,$outData) {
		return CkXml_GetBinaryContent($this->_cPtr,$unzipFlag,$decryptFlag,$password,$outData);
	}

	function GetChild($index) {
		$r=CkXml_GetChild($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetChild2($index) {
		return CkXml_GetChild2($this->_cPtr,$index);
	}

	function getChildAttrValue($tagPath,$attrName) {
		return CkXml_getChildAttrValue($this->_cPtr,$tagPath,$attrName);
	}

	function childAttrValue($tagPath,$attrName) {
		return CkXml_childAttrValue($this->_cPtr,$tagPath,$attrName);
	}

	function GetChildBoolValue($tagPath) {
		return CkXml_GetChildBoolValue($this->_cPtr,$tagPath);
	}

	function getChildContent($tagPath) {
		return CkXml_getChildContent($this->_cPtr,$tagPath);
	}

	function childContent($tagPath) {
		return CkXml_childContent($this->_cPtr,$tagPath);
	}

	function getChildContentByIndex($index) {
		return CkXml_getChildContentByIndex($this->_cPtr,$index);
	}

	function childContentByIndex($index) {
		return CkXml_childContentByIndex($this->_cPtr,$index);
	}

	function GetChildContentSb($tagPath,$sb) {
		return CkXml_GetChildContentSb($this->_cPtr,$tagPath,$sb);
	}

	function GetChildExact($tag,$content) {
		$r=CkXml_GetChildExact($this->_cPtr,$tag,$content);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetChildIntValue($tagPath) {
		return CkXml_GetChildIntValue($this->_cPtr,$tagPath);
	}

	function getChildTag($index) {
		return CkXml_getChildTag($this->_cPtr,$index);
	}

	function childTag($index) {
		return CkXml_childTag($this->_cPtr,$index);
	}

	function getChildTagByIndex($index) {
		return CkXml_getChildTagByIndex($this->_cPtr,$index);
	}

	function childTagByIndex($index) {
		return CkXml_childTagByIndex($this->_cPtr,$index);
	}

	function GetChildWithAttr($tagPath,$attrName,$attrValue) {
		$r=CkXml_GetChildWithAttr($this->_cPtr,$tagPath,$attrName,$attrValue);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetChildWithContent($content) {
		$r=CkXml_GetChildWithContent($this->_cPtr,$content);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetChildWithTag($tagPath) {
		$r=CkXml_GetChildWithTag($this->_cPtr,$tagPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetChildWithTag2($tagPath) {
		return CkXml_GetChildWithTag2($this->_cPtr,$tagPath);
	}

	function GetNthChildWithTag($tag,$n) {
		$r=CkXml_GetNthChildWithTag($this->_cPtr,$tag,$n);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetNthChildWithTag2($tag,$n) {
		return CkXml_GetNthChildWithTag2($this->_cPtr,$tag,$n);
	}

	function GetParent() {
		$r=CkXml_GetParent($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetParent2() {
		return CkXml_GetParent2($this->_cPtr);
	}

	function GetRoot() {
		$r=CkXml_GetRoot($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetRoot2() {
		CkXml_GetRoot2($this->_cPtr);
	}

	function GetSelf() {
		$r=CkXml_GetSelf($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function getXml() {
		return CkXml_getXml($this->_cPtr);
	}

	function xml() {
		return CkXml_xml($this->_cPtr);
	}

	function GetXmlBd($bd) {
		return CkXml_GetXmlBd($this->_cPtr,$bd);
	}

	function GetXmlSb($sb) {
		return CkXml_GetXmlSb($this->_cPtr,$sb);
	}

	function HasAttribute($name) {
		return CkXml_HasAttribute($this->_cPtr,$name);
	}

	function HasAttrWithValue($name,$value) {
		return CkXml_HasAttrWithValue($this->_cPtr,$name,$value);
	}

	function HasChildWithContent($content) {
		return CkXml_HasChildWithContent($this->_cPtr,$content);
	}

	function HasChildWithTag($tagPath) {
		return CkXml_HasChildWithTag($this->_cPtr,$tagPath);
	}

	function HasChildWithTagAndContent($tagPath,$content) {
		return CkXml_HasChildWithTagAndContent($this->_cPtr,$tagPath,$content);
	}

	function InsertChildTreeAfter($index,$tree) {
		CkXml_InsertChildTreeAfter($this->_cPtr,$index,$tree);
	}

	function InsertChildTreeBefore($index,$tree) {
		CkXml_InsertChildTreeBefore($this->_cPtr,$index,$tree);
	}

	function LastChild() {
		$r=CkXml_LastChild($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function LastChild2() {
		return CkXml_LastChild2($this->_cPtr);
	}

	function LoadBd($bd,$autoTrim) {
		return CkXml_LoadBd($this->_cPtr,$bd,$autoTrim);
	}

	function LoadSb($sb,$autoTrim) {
		return CkXml_LoadSb($this->_cPtr,$sb,$autoTrim);
	}

	function LoadXml($xmlData) {
		return CkXml_LoadXml($this->_cPtr,$xmlData);
	}

	function LoadXml2($xmlData,$autoTrim) {
		return CkXml_LoadXml2($this->_cPtr,$xmlData,$autoTrim);
	}

	function LoadXmlFile($fileName) {
		return CkXml_LoadXmlFile($this->_cPtr,$fileName);
	}

	function LoadXmlFile2($fileName,$autoTrim) {
		return CkXml_LoadXmlFile2($this->_cPtr,$fileName,$autoTrim);
	}

	function NewChild($tagPath,$content) {
		$r=CkXml_NewChild($this->_cPtr,$tagPath,$content);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function NewChild2($tagPath,$content) {
		CkXml_NewChild2($this->_cPtr,$tagPath,$content);
	}

	function NewChildAfter($index,$tag,$content) {
		$r=CkXml_NewChildAfter($this->_cPtr,$index,$tag,$content);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function NewChildBefore($index,$tag,$content) {
		$r=CkXml_NewChildBefore($this->_cPtr,$index,$tag,$content);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function NewChildInt2($tagPath,$value) {
		CkXml_NewChildInt2($this->_cPtr,$tagPath,$value);
	}

	function NextInTraversal2($sbState) {
		return CkXml_NextInTraversal2($this->_cPtr,$sbState);
	}

	function NextSibling() {
		$r=CkXml_NextSibling($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function NextSibling2() {
		return CkXml_NextSibling2($this->_cPtr);
	}

	function NumChildrenAt($tagPath) {
		return CkXml_NumChildrenAt($this->_cPtr,$tagPath);
	}

	function NumChildrenHavingTag($tag) {
		return CkXml_NumChildrenHavingTag($this->_cPtr,$tag);
	}

	function PreviousSibling() {
		$r=CkXml_PreviousSibling($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function PreviousSibling2() {
		return CkXml_PreviousSibling2($this->_cPtr);
	}

	function PruneAttribute($attrName) {
		return CkXml_PruneAttribute($this->_cPtr,$attrName);
	}

	function PruneTag($tag) {
		return CkXml_PruneTag($this->_cPtr,$tag);
	}

	function QEncodeContent($charset,$inData) {
		return CkXml_QEncodeContent($this->_cPtr,$charset,$inData);
	}

	function RemoveAllAttributes() {
		return CkXml_RemoveAllAttributes($this->_cPtr);
	}

	function RemoveAllChildren() {
		CkXml_RemoveAllChildren($this->_cPtr);
	}

	function RemoveAttribute($name) {
		return CkXml_RemoveAttribute($this->_cPtr,$name);
	}

	function RemoveChild($tagPath) {
		CkXml_RemoveChild($this->_cPtr,$tagPath);
	}

	function RemoveChildByIndex($index) {
		CkXml_RemoveChildByIndex($this->_cPtr,$index);
	}

	function RemoveChildWithContent($content) {
		CkXml_RemoveChildWithContent($this->_cPtr,$content);
	}

	function RemoveFromTree() {
		CkXml_RemoveFromTree($this->_cPtr);
	}

	function RemoveStyleSheet($attrName,$attrValue) {
		return CkXml_RemoveStyleSheet($this->_cPtr,$attrName,$attrValue);
	}

	function SaveBinaryContent($filename,$unzipFlag,$decryptFlag,$password) {
		return CkXml_SaveBinaryContent($this->_cPtr,$filename,$unzipFlag,$decryptFlag,$password);
	}

	function SaveXml($fileName) {
		return CkXml_SaveXml($this->_cPtr,$fileName);
	}

	function Scrub($directives) {
		CkXml_Scrub($this->_cPtr,$directives);
	}

	function SearchAllForContent($afterPtr,$contentPattern) {
		$r=CkXml_SearchAllForContent($this->_cPtr,$afterPtr,$contentPattern);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function SearchAllForContent2($afterPtr,$contentPattern) {
		return CkXml_SearchAllForContent2($this->_cPtr,$afterPtr,$contentPattern);
	}

	function SearchForAttribute($afterPtr,$tag,$attr,$valuePattern) {
		$r=CkXml_SearchForAttribute($this->_cPtr,$afterPtr,$tag,$attr,$valuePattern);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function SearchForAttribute2($afterPtr,$tag,$attr,$valuePattern) {
		return CkXml_SearchForAttribute2($this->_cPtr,$afterPtr,$tag,$attr,$valuePattern);
	}

	function SearchForContent($afterPtr,$tag,$contentPattern) {
		$r=CkXml_SearchForContent($this->_cPtr,$afterPtr,$tag,$contentPattern);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function SearchForContent2($afterPtr,$tag,$contentPattern) {
		return CkXml_SearchForContent2($this->_cPtr,$afterPtr,$tag,$contentPattern);
	}

	function SearchForTag($afterPtr,$tag) {
		$r=CkXml_SearchForTag($this->_cPtr,$afterPtr,$tag);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function SearchForTag2($afterPtr,$tag) {
		return CkXml_SearchForTag2($this->_cPtr,$afterPtr,$tag);
	}

	function SetBinaryContent($inData,$zipFlag,$encryptFlag,$password) {
		return CkXml_SetBinaryContent($this->_cPtr,$inData,$zipFlag,$encryptFlag,$password);
	}

	function SetBinaryContentBd($data,$zipFlag,$encryptFlag,$password) {
		return CkXml_SetBinaryContentBd($this->_cPtr,$data,$zipFlag,$encryptFlag,$password);
	}

	function SetBinaryContentFromFile($filename,$zipFlag,$encryptFlag,$password) {
		return CkXml_SetBinaryContentFromFile($this->_cPtr,$filename,$zipFlag,$encryptFlag,$password);
	}

	function SortByAttribute($attrName,$ascending) {
		CkXml_SortByAttribute($this->_cPtr,$attrName,$ascending);
	}

	function SortByAttributeInt($attrName,$ascending) {
		CkXml_SortByAttributeInt($this->_cPtr,$attrName,$ascending);
	}

	function SortByContent($ascending) {
		CkXml_SortByContent($this->_cPtr,$ascending);
	}

	function SortByTag($ascending) {
		CkXml_SortByTag($this->_cPtr,$ascending);
	}

	function SortRecordsByAttribute($sortTag,$attrName,$ascending) {
		CkXml_SortRecordsByAttribute($this->_cPtr,$sortTag,$attrName,$ascending);
	}

	function SortRecordsByContent($sortTag,$ascending) {
		CkXml_SortRecordsByContent($this->_cPtr,$sortTag,$ascending);
	}

	function SortRecordsByContentInt($sortTag,$ascending) {
		CkXml_SortRecordsByContentInt($this->_cPtr,$sortTag,$ascending);
	}

	function SwapNode($node) {
		return CkXml_SwapNode($this->_cPtr,$node);
	}

	function SwapTree($tree) {
		return CkXml_SwapTree($this->_cPtr,$tree);
	}

	function tagContent($tagName) {
		return CkXml_tagContent($this->_cPtr,$tagName);
	}

	function TagEquals($tag) {
		return CkXml_TagEquals($this->_cPtr,$tag);
	}

	function TagIndex($tagPath) {
		return CkXml_TagIndex($this->_cPtr,$tagPath);
	}

	function TagNsEquals($ns) {
		return CkXml_TagNsEquals($this->_cPtr,$ns);
	}

	function TagUnpEquals($unprefixedTag) {
		return CkXml_TagUnpEquals($this->_cPtr,$unprefixedTag);
	}

	function UnzipContent() {
		return CkXml_UnzipContent($this->_cPtr);
	}

	function UnzipTree() {
		return CkXml_UnzipTree($this->_cPtr);
	}

	function UpdateAt($tagPath,$autoCreate,$value) {
		return CkXml_UpdateAt($this->_cPtr,$tagPath,$autoCreate,$value);
	}

	function UpdateAttrAt($tagPath,$autoCreate,$attrName,$attrValue) {
		return CkXml_UpdateAttrAt($this->_cPtr,$tagPath,$autoCreate,$attrName,$attrValue);
	}

	function UpdateAttribute($attrName,$attrValue) {
		return CkXml_UpdateAttribute($this->_cPtr,$attrName,$attrValue);
	}

	function UpdateAttributeInt($attrName,$value) {
		return CkXml_UpdateAttributeInt($this->_cPtr,$attrName,$value);
	}

	function UpdateChildContent($tagPath,$value) {
		CkXml_UpdateChildContent($this->_cPtr,$tagPath,$value);
	}

	function UpdateChildContentInt($tagPath,$value) {
		CkXml_UpdateChildContentInt($this->_cPtr,$tagPath,$value);
	}

	function ZipContent() {
		return CkXml_ZipContent($this->_cPtr);
	}

	function ZipTree() {
		return CkXml_ZipTree($this->_cPtr);
	}
}

class CkXmlCertVault {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkXmlCertVault') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkXmlCertVault();
	}

	function get_Utf8() {
		return CkXmlCertVault_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkXmlCertVault_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkXmlCertVault_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkXmlCertVault_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkXmlCertVault_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkXmlCertVault_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkXmlCertVault_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkXmlCertVault_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkXmlCertVault_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkXmlCertVault_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkXmlCertVault_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkXmlCertVault_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkXmlCertVault_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_MasterPassword($str) {
		CkXmlCertVault_get_MasterPassword($this->_cPtr,$str);
	}

	function masterPassword() {
		return CkXmlCertVault_masterPassword($this->_cPtr);
	}

	function put_MasterPassword($newVal) {
		CkXmlCertVault_put_MasterPassword($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkXmlCertVault_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkXmlCertVault_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkXmlCertVault_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkXmlCertVault_version($this->_cPtr);
	}

	function AddCert($cert) {
		return CkXmlCertVault_AddCert($this->_cPtr,$cert);
	}

	function AddCertBinary($certBytes) {
		return CkXmlCertVault_AddCertBinary($this->_cPtr,$certBytes);
	}

	function AddCertChain($certChain) {
		return CkXmlCertVault_AddCertChain($this->_cPtr,$certChain);
	}

	function AddCertEncoded($encodedBytes,$encoding) {
		return CkXmlCertVault_AddCertEncoded($this->_cPtr,$encodedBytes,$encoding);
	}

	function AddCertFile($path) {
		return CkXmlCertVault_AddCertFile($this->_cPtr,$path);
	}

	function AddCertString($certData) {
		return CkXmlCertVault_AddCertString($this->_cPtr,$certData);
	}

	function AddPemFile($path,$password) {
		return CkXmlCertVault_AddPemFile($this->_cPtr,$path,$password);
	}

	function AddPfx($pfx) {
		return CkXmlCertVault_AddPfx($this->_cPtr,$pfx);
	}

	function AddPfxBinary($pfxBytes,$password) {
		return CkXmlCertVault_AddPfxBinary($this->_cPtr,$pfxBytes,$password);
	}

	function AddPfxEncoded($encodedBytes,$encoding,$password) {
		return CkXmlCertVault_AddPfxEncoded($this->_cPtr,$encodedBytes,$encoding,$password);
	}

	function AddPfxFile($path,$password) {
		return CkXmlCertVault_AddPfxFile($this->_cPtr,$path,$password);
	}

	function getXml() {
		return CkXmlCertVault_getXml($this->_cPtr);
	}

	function xml() {
		return CkXmlCertVault_xml($this->_cPtr);
	}

	function LoadXml($xml) {
		return CkXmlCertVault_LoadXml($this->_cPtr,$xml);
	}

	function LoadXmlFile($path) {
		return CkXmlCertVault_LoadXmlFile($this->_cPtr,$path);
	}

	function SaveXml($path) {
		return CkXmlCertVault_SaveXml($this->_cPtr,$path);
	}
}

class CkXmlDSig {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkXmlDSig') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkXmlDSig();
	}

	function get_Utf8() {
		return CkXmlDSig_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkXmlDSig_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkXmlDSig_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkXmlDSig_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkXmlDSig_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_ExternalRefDirs($str) {
		CkXmlDSig_get_ExternalRefDirs($this->_cPtr,$str);
	}

	function externalRefDirs() {
		return CkXmlDSig_externalRefDirs($this->_cPtr);
	}

	function put_ExternalRefDirs($newVal) {
		CkXmlDSig_put_ExternalRefDirs($this->_cPtr,$newVal);
	}

	function get_IgnoreExternalRefs() {
		return CkXmlDSig_get_IgnoreExternalRefs($this->_cPtr);
	}

	function put_IgnoreExternalRefs($newVal) {
		CkXmlDSig_put_IgnoreExternalRefs($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkXmlDSig_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkXmlDSig_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkXmlDSig_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkXmlDSig_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkXmlDSig_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkXmlDSig_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkXmlDSig_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkXmlDSig_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumReferences() {
		return CkXmlDSig_get_NumReferences($this->_cPtr);
	}

	function get_NumSignatures() {
		return CkXmlDSig_get_NumSignatures($this->_cPtr);
	}

	function get_RefFailReason() {
		return CkXmlDSig_get_RefFailReason($this->_cPtr);
	}

	function get_Selector() {
		return CkXmlDSig_get_Selector($this->_cPtr);
	}

	function put_Selector($newVal) {
		CkXmlDSig_put_Selector($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkXmlDSig_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkXmlDSig_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkXmlDSig_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkXmlDSig_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkXmlDSig_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkXmlDSig_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkXmlDSig_version($this->_cPtr);
	}

	function AddEncapsulatedTimeStamp($json,$sbOut) {
		return CkXmlDSig_AddEncapsulatedTimeStamp($this->_cPtr,$json,$sbOut);
	}

	function canonicalizeFragment($xml,$fragmentId,$version,$prefixList,$withComments) {
		return CkXmlDSig_canonicalizeFragment($this->_cPtr,$xml,$fragmentId,$version,$prefixList,$withComments);
	}

	function canonicalizeXml($xml,$version,$withComments) {
		return CkXmlDSig_canonicalizeXml($this->_cPtr,$xml,$version,$withComments);
	}

	function GetCerts($sa) {
		return CkXmlDSig_GetCerts($this->_cPtr,$sa);
	}

	function GetKeyInfo() {
		$r=CkXmlDSig_GetKeyInfo($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetPublicKey() {
		$r=CkXmlDSig_GetPublicKey($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkPublicKey($r);
		}
		return $r;
	}

	function HasEncapsulatedTimeStamp() {
		return CkXmlDSig_HasEncapsulatedTimeStamp($this->_cPtr);
	}

	function IsReferenceExternal($index) {
		return CkXmlDSig_IsReferenceExternal($this->_cPtr,$index);
	}

	function LoadSignature($xmlSig) {
		return CkXmlDSig_LoadSignature($this->_cPtr,$xmlSig);
	}

	function LoadSignatureBd($binData) {
		return CkXmlDSig_LoadSignatureBd($this->_cPtr,$binData);
	}

	function LoadSignatureSb($sbXmlSig) {
		return CkXmlDSig_LoadSignatureSb($this->_cPtr,$sbXmlSig);
	}

	function referenceUri($index) {
		return CkXmlDSig_referenceUri($this->_cPtr,$index);
	}

	function SetHmacKey($key,$encoding) {
		return CkXmlDSig_SetHmacKey($this->_cPtr,$key,$encoding);
	}

	function SetHttpObj($http) {
		CkXmlDSig_SetHttpObj($this->_cPtr,$http);
	}

	function SetPublicKey($pubKey) {
		return CkXmlDSig_SetPublicKey($this->_cPtr,$pubKey);
	}

	function SetRefDataBd($index,$binData) {
		return CkXmlDSig_SetRefDataBd($this->_cPtr,$index,$binData);
	}

	function SetRefDataFile($index,$path) {
		return CkXmlDSig_SetRefDataFile($this->_cPtr,$index,$path);
	}

	function SetRefDataSb($index,$sb,$charset) {
		return CkXmlDSig_SetRefDataSb($this->_cPtr,$index,$sb,$charset);
	}

	function UseCertVault($certVault) {
		return CkXmlDSig_UseCertVault($this->_cPtr,$certVault);
	}

	function VerifyReferenceDigest($index) {
		return CkXmlDSig_VerifyReferenceDigest($this->_cPtr,$index);
	}

	function VerifySignature($verifyReferenceDigests) {
		return CkXmlDSig_VerifySignature($this->_cPtr,$verifyReferenceDigests);
	}
}

class CkXmlDSigGen {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkXmlDSigGen') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkXmlDSigGen();
	}

	function get_Utf8() {
		return CkXmlDSigGen_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkXmlDSigGen_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkXmlDSigGen_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_Behaviors($str) {
		CkXmlDSigGen_get_Behaviors($this->_cPtr,$str);
	}

	function behaviors() {
		return CkXmlDSigGen_behaviors($this->_cPtr);
	}

	function put_Behaviors($newVal) {
		CkXmlDSigGen_put_Behaviors($this->_cPtr,$newVal);
	}

	function get_CustomKeyInfoXml($str) {
		CkXmlDSigGen_get_CustomKeyInfoXml($this->_cPtr,$str);
	}

	function customKeyInfoXml() {
		return CkXmlDSigGen_customKeyInfoXml($this->_cPtr);
	}

	function put_CustomKeyInfoXml($newVal) {
		CkXmlDSigGen_put_CustomKeyInfoXml($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkXmlDSigGen_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkXmlDSigGen_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkXmlDSigGen_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_IncNamespacePrefix($str) {
		CkXmlDSigGen_get_IncNamespacePrefix($this->_cPtr,$str);
	}

	function incNamespacePrefix() {
		return CkXmlDSigGen_incNamespacePrefix($this->_cPtr);
	}

	function put_IncNamespacePrefix($newVal) {
		CkXmlDSigGen_put_IncNamespacePrefix($this->_cPtr,$newVal);
	}

	function get_IncNamespaceUri($str) {
		CkXmlDSigGen_get_IncNamespaceUri($this->_cPtr,$str);
	}

	function incNamespaceUri() {
		return CkXmlDSigGen_incNamespaceUri($this->_cPtr);
	}

	function put_IncNamespaceUri($newVal) {
		CkXmlDSigGen_put_IncNamespaceUri($this->_cPtr,$newVal);
	}

	function get_KeyInfoId($str) {
		CkXmlDSigGen_get_KeyInfoId($this->_cPtr,$str);
	}

	function keyInfoId() {
		return CkXmlDSigGen_keyInfoId($this->_cPtr);
	}

	function put_KeyInfoId($newVal) {
		CkXmlDSigGen_put_KeyInfoId($this->_cPtr,$newVal);
	}

	function get_KeyInfoKeyName($str) {
		CkXmlDSigGen_get_KeyInfoKeyName($this->_cPtr,$str);
	}

	function keyInfoKeyName() {
		return CkXmlDSigGen_keyInfoKeyName($this->_cPtr);
	}

	function put_KeyInfoKeyName($newVal) {
		CkXmlDSigGen_put_KeyInfoKeyName($this->_cPtr,$newVal);
	}

	function get_KeyInfoType($str) {
		CkXmlDSigGen_get_KeyInfoType($this->_cPtr,$str);
	}

	function keyInfoType() {
		return CkXmlDSigGen_keyInfoType($this->_cPtr);
	}

	function put_KeyInfoType($newVal) {
		CkXmlDSigGen_put_KeyInfoType($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkXmlDSigGen_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkXmlDSigGen_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkXmlDSigGen_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkXmlDSigGen_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkXmlDSigGen_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkXmlDSigGen_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkXmlDSigGen_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkXmlDSigGen_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_SigId($str) {
		CkXmlDSigGen_get_SigId($this->_cPtr,$str);
	}

	function sigId() {
		return CkXmlDSigGen_sigId($this->_cPtr);
	}

	function put_SigId($newVal) {
		CkXmlDSigGen_put_SigId($this->_cPtr,$newVal);
	}

	function get_SigLocation($str) {
		CkXmlDSigGen_get_SigLocation($this->_cPtr,$str);
	}

	function sigLocation() {
		return CkXmlDSigGen_sigLocation($this->_cPtr);
	}

	function put_SigLocation($newVal) {
		CkXmlDSigGen_put_SigLocation($this->_cPtr,$newVal);
	}

	function get_SigLocationIdx() {
		return CkXmlDSigGen_get_SigLocationIdx($this->_cPtr);
	}

	function put_SigLocationIdx($newVal) {
		CkXmlDSigGen_put_SigLocationIdx($this->_cPtr,$newVal);
	}

	function get_SigLocationMod() {
		return CkXmlDSigGen_get_SigLocationMod($this->_cPtr);
	}

	function put_SigLocationMod($newVal) {
		CkXmlDSigGen_put_SigLocationMod($this->_cPtr,$newVal);
	}

	function get_SigNamespacePrefix($str) {
		CkXmlDSigGen_get_SigNamespacePrefix($this->_cPtr,$str);
	}

	function sigNamespacePrefix() {
		return CkXmlDSigGen_sigNamespacePrefix($this->_cPtr);
	}

	function put_SigNamespacePrefix($newVal) {
		CkXmlDSigGen_put_SigNamespacePrefix($this->_cPtr,$newVal);
	}

	function get_SigNamespaceUri($str) {
		CkXmlDSigGen_get_SigNamespaceUri($this->_cPtr,$str);
	}

	function sigNamespaceUri() {
		return CkXmlDSigGen_sigNamespaceUri($this->_cPtr);
	}

	function put_SigNamespaceUri($newVal) {
		CkXmlDSigGen_put_SigNamespaceUri($this->_cPtr,$newVal);
	}

	function get_SignedInfoCanonAlg($str) {
		CkXmlDSigGen_get_SignedInfoCanonAlg($this->_cPtr,$str);
	}

	function signedInfoCanonAlg() {
		return CkXmlDSigGen_signedInfoCanonAlg($this->_cPtr);
	}

	function put_SignedInfoCanonAlg($newVal) {
		CkXmlDSigGen_put_SignedInfoCanonAlg($this->_cPtr,$newVal);
	}

	function get_SignedInfoDigestMethod($str) {
		CkXmlDSigGen_get_SignedInfoDigestMethod($this->_cPtr,$str);
	}

	function signedInfoDigestMethod() {
		return CkXmlDSigGen_signedInfoDigestMethod($this->_cPtr);
	}

	function put_SignedInfoDigestMethod($newVal) {
		CkXmlDSigGen_put_SignedInfoDigestMethod($this->_cPtr,$newVal);
	}

	function get_SignedInfoId($str) {
		CkXmlDSigGen_get_SignedInfoId($this->_cPtr,$str);
	}

	function signedInfoId() {
		return CkXmlDSigGen_signedInfoId($this->_cPtr);
	}

	function put_SignedInfoId($newVal) {
		CkXmlDSigGen_put_SignedInfoId($this->_cPtr,$newVal);
	}

	function get_SignedInfoPrefixList($str) {
		CkXmlDSigGen_get_SignedInfoPrefixList($this->_cPtr,$str);
	}

	function signedInfoPrefixList() {
		return CkXmlDSigGen_signedInfoPrefixList($this->_cPtr);
	}

	function put_SignedInfoPrefixList($newVal) {
		CkXmlDSigGen_put_SignedInfoPrefixList($this->_cPtr,$newVal);
	}

	function get_SigningAlg($str) {
		CkXmlDSigGen_get_SigningAlg($this->_cPtr,$str);
	}

	function signingAlg() {
		return CkXmlDSigGen_signingAlg($this->_cPtr);
	}

	function put_SigningAlg($newVal) {
		CkXmlDSigGen_put_SigningAlg($this->_cPtr,$newVal);
	}

	function get_SigValueId($str) {
		CkXmlDSigGen_get_SigValueId($this->_cPtr,$str);
	}

	function sigValueId() {
		return CkXmlDSigGen_sigValueId($this->_cPtr);
	}

	function put_SigValueId($newVal) {
		CkXmlDSigGen_put_SigValueId($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkXmlDSigGen_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkXmlDSigGen_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkXmlDSigGen_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkXmlDSigGen_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkXmlDSigGen_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkXmlDSigGen_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkXmlDSigGen_version($this->_cPtr);
	}

	function get_X509Type($str) {
		CkXmlDSigGen_get_X509Type($this->_cPtr,$str);
	}

	function x509Type() {
		return CkXmlDSigGen_x509Type($this->_cPtr);
	}

	function put_X509Type($newVal) {
		CkXmlDSigGen_put_X509Type($this->_cPtr,$newVal);
	}

	function AddEnvelopedRef($id,$content,$digestMethod,$canonMethod,$refType) {
		return CkXmlDSigGen_AddEnvelopedRef($this->_cPtr,$id,$content,$digestMethod,$canonMethod,$refType);
	}

	function AddExternalBinaryRef($uri,$content,$digestMethod,$refType) {
		return CkXmlDSigGen_AddExternalBinaryRef($this->_cPtr,$uri,$content,$digestMethod,$refType);
	}

	function AddExternalFileRef($uri,$localFilePath,$digestMethod,$refType) {
		return CkXmlDSigGen_AddExternalFileRef($this->_cPtr,$uri,$localFilePath,$digestMethod,$refType);
	}

	function AddExternalTextRef($uri,$content,$charset,$includeBom,$digestMethod,$refType) {
		return CkXmlDSigGen_AddExternalTextRef($this->_cPtr,$uri,$content,$charset,$includeBom,$digestMethod,$refType);
	}

	function AddExternalXmlRef($uri,$content,$digestMethod,$canonMethod,$refType) {
		return CkXmlDSigGen_AddExternalXmlRef($this->_cPtr,$uri,$content,$digestMethod,$canonMethod,$refType);
	}

	function AddObject($id,$content,$mimeType,$encoding) {
		return CkXmlDSigGen_AddObject($this->_cPtr,$id,$content,$mimeType,$encoding);
	}

	function AddObjectRef($id,$digestMethod,$canonMethod,$prefixList,$refType) {
		return CkXmlDSigGen_AddObjectRef($this->_cPtr,$id,$digestMethod,$canonMethod,$prefixList,$refType);
	}

	function AddObjectRef2($id,$digestMethod,$transforms,$refType) {
		return CkXmlDSigGen_AddObjectRef2($this->_cPtr,$id,$digestMethod,$transforms,$refType);
	}

	function AddSameDocRef($id,$digestMethod,$canonMethod,$prefixList,$refType) {
		return CkXmlDSigGen_AddSameDocRef($this->_cPtr,$id,$digestMethod,$canonMethod,$prefixList,$refType);
	}

	function AddSameDocRef2($id,$digestMethod,$transforms,$refType) {
		return CkXmlDSigGen_AddSameDocRef2($this->_cPtr,$id,$digestMethod,$transforms,$refType);
	}

	function AddSignatureNamespace($nsPrefix,$nsUri) {
		return CkXmlDSigGen_AddSignatureNamespace($this->_cPtr,$nsPrefix,$nsUri);
	}

	function constructSignedInfo($sbXml) {
		return CkXmlDSigGen_constructSignedInfo($this->_cPtr,$sbXml);
	}

	function createXmlDSig($inXml) {
		return CkXmlDSigGen_createXmlDSig($this->_cPtr,$inXml);
	}

	function CreateXmlDSigAsync($inXml) {
		$r=CkXmlDSigGen_CreateXmlDSigAsync($this->_cPtr,$inXml);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function CreateXmlDSigSb($sbXml) {
		return CkXmlDSigGen_CreateXmlDSigSb($this->_cPtr,$sbXml);
	}

	function CreateXmlDSigSbAsync($sbXml) {
		$r=CkXmlDSigGen_CreateXmlDSigSbAsync($this->_cPtr,$sbXml);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function SetHmacKey($key,$encoding) {
		return CkXmlDSigGen_SetHmacKey($this->_cPtr,$key,$encoding);
	}

	function SetHttpObj($http) {
		CkXmlDSigGen_SetHttpObj($this->_cPtr,$http);
	}

	function SetPrivateKey($privKey) {
		return CkXmlDSigGen_SetPrivateKey($this->_cPtr,$privKey);
	}

	function SetRefIdAttr($uri_or_id,$value) {
		return CkXmlDSigGen_SetRefIdAttr($this->_cPtr,$uri_or_id,$value);
	}

	function SetTsa($json) {
		return CkXmlDSigGen_SetTsa($this->_cPtr,$json);
	}

	function SetX509Cert($cert,$usePrivateKey) {
		return CkXmlDSigGen_SetX509Cert($this->_cPtr,$cert,$usePrivateKey);
	}
}

class CkXmp {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkXmp') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkXmp();
	}

	function get_Utf8() {
		return CkXmp_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkXmp_put_Utf8($this->_cPtr,$b);
	}

	function get_DebugLogFilePath($str) {
		CkXmp_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkXmp_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkXmp_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkXmp_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkXmp_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkXmp_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkXmp_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkXmp_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkXmp_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkXmp_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkXmp_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_NumEmbedded() {
		return CkXmp_get_NumEmbedded($this->_cPtr);
	}

	function get_StructInnerDescrip() {
		return CkXmp_get_StructInnerDescrip($this->_cPtr);
	}

	function put_StructInnerDescrip($newVal) {
		CkXmp_put_StructInnerDescrip($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkXmp_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkXmp_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkXmp_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkXmp_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkXmp_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkXmp_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkXmp_version($this->_cPtr);
	}

	function AddArray($xml,$arrType,$propName,$values) {
		return CkXmp_AddArray($this->_cPtr,$xml,$arrType,$propName,$values);
	}

	function AddNsMapping($ns,$uri) {
		CkXmp_AddNsMapping($this->_cPtr,$ns,$uri);
	}

	function AddSimpleInt($iXml,$propName,$propVal) {
		return CkXmp_AddSimpleInt($this->_cPtr,$iXml,$propName,$propVal);
	}

	function AddSimpleStr($iXml,$propName,$propVal) {
		return CkXmp_AddSimpleStr($this->_cPtr,$iXml,$propName,$propVal);
	}

	function AddStructProp($iChilkatXml,$structName,$propName,$propValue) {
		return CkXmp_AddStructProp($this->_cPtr,$iChilkatXml,$structName,$propName,$propValue);
	}

	function Append($iXml) {
		return CkXmp_Append($this->_cPtr,$iXml);
	}

	function GetArray($iXml,$propName) {
		$r=CkXmp_GetArray($this->_cPtr,$iXml,$propName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function GetEmbedded($index) {
		$r=CkXmp_GetEmbedded($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetProperty($iXml,$propName) {
		$r=CkXmp_GetProperty($this->_cPtr,$iXml,$propName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function GetSimpleInt($iXml,$propName) {
		return CkXmp_GetSimpleInt($this->_cPtr,$iXml,$propName);
	}

	function getSimpleStr($iXml,$propName) {
		return CkXmp_getSimpleStr($this->_cPtr,$iXml,$propName);
	}

	function simpleStr($iXml,$propName) {
		return CkXmp_simpleStr($this->_cPtr,$iXml,$propName);
	}

	function GetStructPropNames($iXml,$structName) {
		$r=CkXmp_GetStructPropNames($this->_cPtr,$iXml,$structName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function getStructValue($iXml,$structName,$propName) {
		return CkXmp_getStructValue($this->_cPtr,$iXml,$structName,$propName);
	}

	function structValue($iXml,$structName,$propName) {
		return CkXmp_structValue($this->_cPtr,$iXml,$structName,$propName);
	}

	function LoadAppFile($filename) {
		return CkXmp_LoadAppFile($this->_cPtr,$filename);
	}

	function LoadFromBuffer($fileData,$ext) {
		return CkXmp_LoadFromBuffer($this->_cPtr,$fileData,$ext);
	}

	function NewXmp() {
		$r=CkXmp_NewXmp($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkXml($r);
		}
		return $r;
	}

	function RemoveAllEmbedded() {
		return CkXmp_RemoveAllEmbedded($this->_cPtr);
	}

	function RemoveArray($iXml,$propName) {
		return CkXmp_RemoveArray($this->_cPtr,$iXml,$propName);
	}

	function RemoveEmbedded($index) {
		return CkXmp_RemoveEmbedded($this->_cPtr,$index);
	}

	function RemoveNsMapping($ns) {
		CkXmp_RemoveNsMapping($this->_cPtr,$ns);
	}

	function RemoveSimple($iXml,$propName) {
		return CkXmp_RemoveSimple($this->_cPtr,$iXml,$propName);
	}

	function RemoveStruct($iXml,$structName) {
		return CkXmp_RemoveStruct($this->_cPtr,$iXml,$structName);
	}

	function RemoveStructProp($iXml,$structName,$propName) {
		return CkXmp_RemoveStructProp($this->_cPtr,$iXml,$structName,$propName);
	}

	function SaveAppFile($filename) {
		return CkXmp_SaveAppFile($this->_cPtr,$filename);
	}

	function SaveToBuffer($outBytes) {
		return CkXmp_SaveToBuffer($this->_cPtr,$outBytes);
	}
}

class CkZip {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkZip') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkZip();
	}

	function get_Utf8() {
		return CkZip_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkZip_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkZip_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_AbortCurrent() {
		return CkZip_get_AbortCurrent($this->_cPtr);
	}

	function put_AbortCurrent($newVal) {
		CkZip_put_AbortCurrent($this->_cPtr,$newVal);
	}

	function get_AppendFromDir($str) {
		CkZip_get_AppendFromDir($this->_cPtr,$str);
	}

	function appendFromDir() {
		return CkZip_appendFromDir($this->_cPtr);
	}

	function put_AppendFromDir($newVal) {
		CkZip_put_AppendFromDir($this->_cPtr,$newVal);
	}

	function get_AutoRun($str) {
		CkZip_get_AutoRun($this->_cPtr,$str);
	}

	function autoRun() {
		return CkZip_autoRun($this->_cPtr);
	}

	function put_AutoRun($newVal) {
		CkZip_put_AutoRun($this->_cPtr,$newVal);
	}

	function get_AutoRunParams($str) {
		CkZip_get_AutoRunParams($this->_cPtr,$str);
	}

	function autoRunParams() {
		return CkZip_autoRunParams($this->_cPtr);
	}

	function put_AutoRunParams($newVal) {
		CkZip_put_AutoRunParams($this->_cPtr,$newVal);
	}

	function get_AutoTemp() {
		return CkZip_get_AutoTemp($this->_cPtr);
	}

	function put_AutoTemp($newVal) {
		CkZip_put_AutoTemp($this->_cPtr,$newVal);
	}

	function get_CaseSensitive() {
		return CkZip_get_CaseSensitive($this->_cPtr);
	}

	function put_CaseSensitive($newVal) {
		CkZip_put_CaseSensitive($this->_cPtr,$newVal);
	}

	function get_ClearArchiveAttribute() {
		return CkZip_get_ClearArchiveAttribute($this->_cPtr);
	}

	function put_ClearArchiveAttribute($newVal) {
		CkZip_put_ClearArchiveAttribute($this->_cPtr,$newVal);
	}

	function get_ClearReadOnlyAttr() {
		return CkZip_get_ClearReadOnlyAttr($this->_cPtr);
	}

	function put_ClearReadOnlyAttr($newVal) {
		CkZip_put_ClearReadOnlyAttr($this->_cPtr,$newVal);
	}

	function get_Comment($str) {
		CkZip_get_Comment($this->_cPtr,$str);
	}

	function comment() {
		return CkZip_comment($this->_cPtr);
	}

	function put_Comment($newVal) {
		CkZip_put_Comment($this->_cPtr,$newVal);
	}

	function get_DebugLogFilePath($str) {
		CkZip_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkZip_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkZip_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_DecryptPassword($str) {
		CkZip_get_DecryptPassword($this->_cPtr,$str);
	}

	function decryptPassword() {
		return CkZip_decryptPassword($this->_cPtr);
	}

	function put_DecryptPassword($newVal) {
		CkZip_put_DecryptPassword($this->_cPtr,$newVal);
	}

	function get_DiscardPaths() {
		return CkZip_get_DiscardPaths($this->_cPtr);
	}

	function put_DiscardPaths($newVal) {
		CkZip_put_DiscardPaths($this->_cPtr,$newVal);
	}

	function get_Encryption() {
		return CkZip_get_Encryption($this->_cPtr);
	}

	function put_Encryption($newVal) {
		CkZip_put_Encryption($this->_cPtr,$newVal);
	}

	function get_EncryptKeyLength() {
		return CkZip_get_EncryptKeyLength($this->_cPtr);
	}

	function put_EncryptKeyLength($newVal) {
		CkZip_put_EncryptKeyLength($this->_cPtr,$newVal);
	}

	function get_EncryptPassword($str) {
		CkZip_get_EncryptPassword($this->_cPtr,$str);
	}

	function encryptPassword() {
		return CkZip_encryptPassword($this->_cPtr);
	}

	function put_EncryptPassword($newVal) {
		CkZip_put_EncryptPassword($this->_cPtr,$newVal);
	}

	function get_ExeDefaultDir($str) {
		CkZip_get_ExeDefaultDir($this->_cPtr,$str);
	}

	function exeDefaultDir() {
		return CkZip_exeDefaultDir($this->_cPtr);
	}

	function put_ExeDefaultDir($newVal) {
		CkZip_put_ExeDefaultDir($this->_cPtr,$newVal);
	}

	function get_ExeFinishNotifier() {
		return CkZip_get_ExeFinishNotifier($this->_cPtr);
	}

	function put_ExeFinishNotifier($newVal) {
		CkZip_put_ExeFinishNotifier($this->_cPtr,$newVal);
	}

	function get_ExeIconFile($str) {
		CkZip_get_ExeIconFile($this->_cPtr,$str);
	}

	function exeIconFile() {
		return CkZip_exeIconFile($this->_cPtr);
	}

	function put_ExeIconFile($newVal) {
		CkZip_put_ExeIconFile($this->_cPtr,$newVal);
	}

	function get_ExeNoInterface() {
		return CkZip_get_ExeNoInterface($this->_cPtr);
	}

	function put_ExeNoInterface($newVal) {
		CkZip_put_ExeNoInterface($this->_cPtr,$newVal);
	}

	function get_ExeSilentProgress() {
		return CkZip_get_ExeSilentProgress($this->_cPtr);
	}

	function put_ExeSilentProgress($newVal) {
		CkZip_put_ExeSilentProgress($this->_cPtr,$newVal);
	}

	function get_ExeTitle($str) {
		CkZip_get_ExeTitle($this->_cPtr,$str);
	}

	function exeTitle() {
		return CkZip_exeTitle($this->_cPtr);
	}

	function put_ExeTitle($newVal) {
		CkZip_put_ExeTitle($this->_cPtr,$newVal);
	}

	function get_ExeUnzipCaption($str) {
		CkZip_get_ExeUnzipCaption($this->_cPtr,$str);
	}

	function exeUnzipCaption() {
		return CkZip_exeUnzipCaption($this->_cPtr);
	}

	function put_ExeUnzipCaption($newVal) {
		CkZip_put_ExeUnzipCaption($this->_cPtr,$newVal);
	}

	function get_ExeUnzipDir($str) {
		CkZip_get_ExeUnzipDir($this->_cPtr,$str);
	}

	function exeUnzipDir() {
		return CkZip_exeUnzipDir($this->_cPtr);
	}

	function put_ExeUnzipDir($newVal) {
		CkZip_put_ExeUnzipDir($this->_cPtr,$newVal);
	}

	function get_ExeWaitForSetup() {
		return CkZip_get_ExeWaitForSetup($this->_cPtr);
	}

	function put_ExeWaitForSetup($newVal) {
		CkZip_put_ExeWaitForSetup($this->_cPtr,$newVal);
	}

	function get_ExeXmlConfig($str) {
		CkZip_get_ExeXmlConfig($this->_cPtr,$str);
	}

	function exeXmlConfig() {
		return CkZip_exeXmlConfig($this->_cPtr);
	}

	function put_ExeXmlConfig($newVal) {
		CkZip_put_ExeXmlConfig($this->_cPtr,$newVal);
	}

	function get_FileCount() {
		return CkZip_get_FileCount($this->_cPtr);
	}

	function get_FileName($str) {
		CkZip_get_FileName($this->_cPtr,$str);
	}

	function fileName() {
		return CkZip_fileName($this->_cPtr);
	}

	function put_FileName($newVal) {
		CkZip_put_FileName($this->_cPtr,$newVal);
	}

	function get_HasZipFormatErrors() {
		return CkZip_get_HasZipFormatErrors($this->_cPtr);
	}

	function get_HeartbeatMs() {
		return CkZip_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkZip_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_IgnoreAccessDenied() {
		return CkZip_get_IgnoreAccessDenied($this->_cPtr);
	}

	function put_IgnoreAccessDenied($newVal) {
		CkZip_put_IgnoreAccessDenied($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkZip_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkZip_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkZip_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkZip_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkZip_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkZip_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkZip_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkZip_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_MaxDate($str) {
		CkZip_get_MaxDate($this->_cPtr,$str);
	}

	function maxDate() {
		return CkZip_maxDate($this->_cPtr);
	}

	function put_MaxDate($newVal) {
		CkZip_put_MaxDate($this->_cPtr,$newVal);
	}

	function get_MaxUncompressSize() {
		return CkZip_get_MaxUncompressSize($this->_cPtr);
	}

	function put_MaxUncompressSize($newVal) {
		CkZip_put_MaxUncompressSize($this->_cPtr,$newVal);
	}

	function get_MinDate($str) {
		CkZip_get_MinDate($this->_cPtr,$str);
	}

	function minDate() {
		return CkZip_minDate($this->_cPtr);
	}

	function put_MinDate($newVal) {
		CkZip_put_MinDate($this->_cPtr,$newVal);
	}

	function get_NumEntries() {
		return CkZip_get_NumEntries($this->_cPtr);
	}

	function get_OemCodePage() {
		return CkZip_get_OemCodePage($this->_cPtr);
	}

	function put_OemCodePage($newVal) {
		CkZip_put_OemCodePage($this->_cPtr,$newVal);
	}

	function get_OverwriteExisting() {
		return CkZip_get_OverwriteExisting($this->_cPtr);
	}

	function put_OverwriteExisting($newVal) {
		CkZip_put_OverwriteExisting($this->_cPtr,$newVal);
	}

	function get_PasswordProtect() {
		return CkZip_get_PasswordProtect($this->_cPtr);
	}

	function put_PasswordProtect($newVal) {
		CkZip_put_PasswordProtect($this->_cPtr,$newVal);
	}

	function get_PathPrefix($str) {
		CkZip_get_PathPrefix($this->_cPtr,$str);
	}

	function pathPrefix() {
		return CkZip_pathPrefix($this->_cPtr);
	}

	function put_PathPrefix($newVal) {
		CkZip_put_PathPrefix($this->_cPtr,$newVal);
	}

	function get_PercentDoneScale() {
		return CkZip_get_PercentDoneScale($this->_cPtr);
	}

	function put_PercentDoneScale($newVal) {
		CkZip_put_PercentDoneScale($this->_cPtr,$newVal);
	}

	function get_PwdProtCharset($str) {
		CkZip_get_PwdProtCharset($this->_cPtr,$str);
	}

	function pwdProtCharset() {
		return CkZip_pwdProtCharset($this->_cPtr);
	}

	function put_PwdProtCharset($newVal) {
		CkZip_put_PwdProtCharset($this->_cPtr,$newVal);
	}

	function get_TempDir($str) {
		CkZip_get_TempDir($this->_cPtr,$str);
	}

	function tempDir() {
		return CkZip_tempDir($this->_cPtr);
	}

	function put_TempDir($newVal) {
		CkZip_put_TempDir($this->_cPtr,$newVal);
	}

	function get_UncommonOptions($str) {
		CkZip_get_UncommonOptions($this->_cPtr,$str);
	}

	function uncommonOptions() {
		return CkZip_uncommonOptions($this->_cPtr);
	}

	function put_UncommonOptions($newVal) {
		CkZip_put_UncommonOptions($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkZip_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkZip_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkZip_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkZip_version($this->_cPtr);
	}

	function get_Zipx() {
		return CkZip_get_Zipx($this->_cPtr);
	}

	function put_Zipx($newVal) {
		CkZip_put_Zipx($this->_cPtr,$newVal);
	}

	function get_ZipxDefaultAlg($str) {
		CkZip_get_ZipxDefaultAlg($this->_cPtr,$str);
	}

	function zipxDefaultAlg() {
		return CkZip_zipxDefaultAlg($this->_cPtr);
	}

	function put_ZipxDefaultAlg($newVal) {
		CkZip_put_ZipxDefaultAlg($this->_cPtr,$newVal);
	}

	function AddBd($pathInZip,$bd) {
		return CkZip_AddBd($this->_cPtr,$pathInZip,$bd);
	}

	function AddEmpty($isDir,$pathInZip) {
		return CkZip_AddEmpty($this->_cPtr,$isDir,$pathInZip);
	}

	function AddEncoded($pathInZip,$encoding,$data) {
		return CkZip_AddEncoded($this->_cPtr,$pathInZip,$encoding,$data);
	}

	function AddFile($localPath,$saveExtraPath) {
		return CkZip_AddFile($this->_cPtr,$localPath,$saveExtraPath);
	}

	function AddNoCompressExtension($fileExtension) {
		CkZip_AddNoCompressExtension($this->_cPtr,$fileExtension);
	}

	function AddSb($pathInZip,$sb,$charset) {
		return CkZip_AddSb($this->_cPtr,$pathInZip,$sb,$charset);
	}

	function AddString($pathInZip,$content,$charset) {
		return CkZip_AddString($this->_cPtr,$pathInZip,$content,$charset);
	}

	function AppendBd($pathInZip,$byteData) {
		$r=CkZip_AppendBd($this->_cPtr,$pathInZip,$byteData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function AppendData($fileName,$inData) {
		$r=CkZip_AppendData($this->_cPtr,$fileName,$inData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function AppendDataEncoded($filename,$encoding,$data) {
		$r=CkZip_AppendDataEncoded($this->_cPtr,$filename,$encoding,$data);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function AppendFiles($filePattern,$recurse) {
		return CkZip_AppendFiles($this->_cPtr,$filePattern,$recurse);
	}

	function AppendFilesAsync($filePattern,$recurse) {
		$r=CkZip_AppendFilesAsync($this->_cPtr,$filePattern,$recurse);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendFilesEx($filePattern,$recurse,$saveExtraPath,$archiveOnly,$includeHidden,$includeSystem) {
		return CkZip_AppendFilesEx($this->_cPtr,$filePattern,$recurse,$saveExtraPath,$archiveOnly,$includeHidden,$includeSystem);
	}

	function AppendFilesExAsync($filePattern,$recurse,$saveExtraPath,$archiveOnly,$includeHidden,$includeSystem) {
		$r=CkZip_AppendFilesExAsync($this->_cPtr,$filePattern,$recurse,$saveExtraPath,$archiveOnly,$includeHidden,$includeSystem);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendNew($fileName) {
		$r=CkZip_AppendNew($this->_cPtr,$fileName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function AppendNewDir($dirName) {
		$r=CkZip_AppendNewDir($this->_cPtr,$dirName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function AppendOneFileOrDir($fileOrDirPath,$saveExtraPath) {
		return CkZip_AppendOneFileOrDir($this->_cPtr,$fileOrDirPath,$saveExtraPath);
	}

	function AppendOneFileOrDirAsync($fileOrDirPath,$saveExtraPath) {
		$r=CkZip_AppendOneFileOrDirAsync($this->_cPtr,$fileOrDirPath,$saveExtraPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendSb($pathInZip,$sb,$charset) {
		return CkZip_AppendSb($this->_cPtr,$pathInZip,$sb,$charset);
	}

	function AppendString($internalZipFilepath,$textData) {
		$r=CkZip_AppendString($this->_cPtr,$internalZipFilepath,$textData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function AppendString2($internalZipFilepath,$textData,$charset) {
		$r=CkZip_AppendString2($this->_cPtr,$internalZipFilepath,$textData,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function AppendZip($zipFileName) {
		return CkZip_AppendZip($this->_cPtr,$zipFileName);
	}

	function CloseZip() {
		CkZip_CloseZip($this->_cPtr);
	}

	function DeleteEntry($entry) {
		return CkZip_DeleteEntry($this->_cPtr,$entry);
	}

	function EntryAt($index,$entry) {
		return CkZip_EntryAt($this->_cPtr,$index,$entry);
	}

	function EntryById($id,$entry) {
		return CkZip_EntryById($this->_cPtr,$id,$entry);
	}

	function EntryMatching($pattern,$entry) {
		return CkZip_EntryMatching($this->_cPtr,$pattern,$entry);
	}

	function EntryOf($pathInZip,$entry) {
		return CkZip_EntryOf($this->_cPtr,$pathInZip,$entry);
	}

	function ExcludeDir($dirName) {
		CkZip_ExcludeDir($this->_cPtr,$dirName);
	}

	function ExtractExe($exePath,$dirPath) {
		return CkZip_ExtractExe($this->_cPtr,$exePath,$dirPath);
	}

	function ExtractExeAsync($exePath,$dirPath) {
		$r=CkZip_ExtractExeAsync($this->_cPtr,$exePath,$dirPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function FirstEntry() {
		$r=CkZip_FirstEntry($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function FirstMatchingEntry($pattern) {
		$r=CkZip_FirstMatchingEntry($this->_cPtr,$pattern);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function getDirectoryAsXML() {
		return CkZip_getDirectoryAsXML($this->_cPtr);
	}

	function directoryAsXML() {
		return CkZip_directoryAsXML($this->_cPtr);
	}

	function GetEntryByID($entryID) {
		$r=CkZip_GetEntryByID($this->_cPtr,$entryID);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function GetEntryByIndex($index) {
		$r=CkZip_GetEntryByIndex($this->_cPtr,$index);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function GetEntryByName($entryName) {
		$r=CkZip_GetEntryByName($this->_cPtr,$entryName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function GetExclusions() {
		$r=CkZip_GetExclusions($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkStringArray($r);
		}
		return $r;
	}

	function getExeConfigParam($name) {
		return CkZip_getExeConfigParam($this->_cPtr,$name);
	}

	function exeConfigParam($name) {
		return CkZip_exeConfigParam($this->_cPtr,$name);
	}

	function getMaxUncompressedSize() {
		return CkZip_getMaxUncompressedSize($this->_cPtr);
	}

	function maxUncompressedSize() {
		return CkZip_maxUncompressedSize($this->_cPtr);
	}

	function IsNoCompressExtension($fileExtension) {
		return CkZip_IsNoCompressExtension($this->_cPtr,$fileExtension);
	}

	function IsPasswordProtected($zipFilename) {
		return CkZip_IsPasswordProtected($this->_cPtr,$zipFilename);
	}

	function LoadTaskCaller($task) {
		return CkZip_LoadTaskCaller($this->_cPtr,$task);
	}

	function NewZip($zipFilePath) {
		return CkZip_NewZip($this->_cPtr,$zipFilePath);
	}

	function OpenBd($binData) {
		return CkZip_OpenBd($this->_cPtr,$binData);
	}

	function OpenEmbedded($exeFilename,$resourceName) {
		return CkZip_OpenEmbedded($this->_cPtr,$exeFilename,$resourceName);
	}

	function OpenFromByteData($byteData) {
		return CkZip_OpenFromByteData($this->_cPtr,$byteData);
	}

	function OpenFromMemory($inData) {
		return CkZip_OpenFromMemory($this->_cPtr,$inData);
	}

	function OpenZip($zipPath) {
		return CkZip_OpenZip($this->_cPtr,$zipPath);
	}

	function OpenZipAsync($zipPath) {
		$r=CkZip_OpenZipAsync($this->_cPtr,$zipPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function QuickAppend($ZipFileName) {
		return CkZip_QuickAppend($this->_cPtr,$ZipFileName);
	}

	function QuickAppendAsync($ZipFileName) {
		$r=CkZip_QuickAppendAsync($this->_cPtr,$ZipFileName);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function RemoveNoCompressExtension($fileExtension) {
		CkZip_RemoveNoCompressExtension($this->_cPtr,$fileExtension);
	}

	function SetCompressionLevel($level) {
		CkZip_SetCompressionLevel($this->_cPtr,$level);
	}

	function SetExclusions($excludePatterns) {
		CkZip_SetExclusions($this->_cPtr,$excludePatterns);
	}

	function SetExeConfigParam($paramName,$paramValue) {
		CkZip_SetExeConfigParam($this->_cPtr,$paramName,$paramValue);
	}

	function SetPassword($password) {
		CkZip_SetPassword($this->_cPtr,$password);
	}

	function Unzip($dirPath) {
		return CkZip_Unzip($this->_cPtr,$dirPath);
	}

	function UnzipAsync($dirPath) {
		$r=CkZip_UnzipAsync($this->_cPtr,$dirPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UnzipInto($dirPath) {
		return CkZip_UnzipInto($this->_cPtr,$dirPath);
	}

	function UnzipIntoAsync($dirPath) {
		$r=CkZip_UnzipIntoAsync($this->_cPtr,$dirPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UnzipMatching($dirPath,$pattern,$verbose) {
		return CkZip_UnzipMatching($this->_cPtr,$dirPath,$pattern,$verbose);
	}

	function UnzipMatchingAsync($dirPath,$pattern,$verbose) {
		$r=CkZip_UnzipMatchingAsync($this->_cPtr,$dirPath,$pattern,$verbose);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UnzipMatchingInto($dirPath,$pattern,$verbose) {
		return CkZip_UnzipMatchingInto($this->_cPtr,$dirPath,$pattern,$verbose);
	}

	function UnzipMatchingIntoAsync($dirPath,$pattern,$verbose) {
		$r=CkZip_UnzipMatchingIntoAsync($this->_cPtr,$dirPath,$pattern,$verbose);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UnzipNewer($dirPath) {
		return CkZip_UnzipNewer($this->_cPtr,$dirPath);
	}

	function UnzipNewerAsync($dirPath) {
		$r=CkZip_UnzipNewerAsync($this->_cPtr,$dirPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function VerifyPassword() {
		return CkZip_VerifyPassword($this->_cPtr);
	}

	function WriteBd($binData) {
		return CkZip_WriteBd($this->_cPtr,$binData);
	}

	function WriteBdAsync($binData) {
		$r=CkZip_WriteBdAsync($this->_cPtr,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteExe($exeFilename) {
		return CkZip_WriteExe($this->_cPtr,$exeFilename);
	}

	function WriteExeAsync($exeFilename) {
		$r=CkZip_WriteExeAsync($this->_cPtr,$exeFilename);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteExe2($exePath,$destExePath,$bAesEncrypt,$keyLength,$password) {
		return CkZip_WriteExe2($this->_cPtr,$exePath,$destExePath,$bAesEncrypt,$keyLength,$password);
	}

	function WriteExe2Async($exePath,$destExePath,$bAesEncrypt,$keyLength,$password) {
		$r=CkZip_WriteExe2Async($this->_cPtr,$exePath,$destExePath,$bAesEncrypt,$keyLength,$password);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteExeToMemory($outBytes) {
		return CkZip_WriteExeToMemory($this->_cPtr,$outBytes);
	}

	function WriteExeToMemoryAsync() {
		$r=CkZip_WriteExeToMemoryAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteToMemory($outData) {
		return CkZip_WriteToMemory($this->_cPtr,$outData);
	}

	function WriteToMemoryAsync() {
		$r=CkZip_WriteToMemoryAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteZip() {
		return CkZip_WriteZip($this->_cPtr);
	}

	function WriteZipAsync() {
		$r=CkZip_WriteZipAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function WriteZipAndClose() {
		return CkZip_WriteZipAndClose($this->_cPtr);
	}

	function WriteZipAndCloseAsync() {
		$r=CkZip_WriteZipAndCloseAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}

class CkZipCrc {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkZipCrc') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkZipCrc();
	}

	function get_Utf8() {
		return CkZipCrc_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkZipCrc_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkZipCrc_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_DebugLogFilePath($str) {
		CkZipCrc_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkZipCrc_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkZipCrc_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_LastErrorHtml($str) {
		CkZipCrc_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkZipCrc_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkZipCrc_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkZipCrc_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkZipCrc_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkZipCrc_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkZipCrc_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkZipCrc_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_VerboseLogging() {
		return CkZipCrc_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkZipCrc_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkZipCrc_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkZipCrc_version($this->_cPtr);
	}

	function BeginStream() {
		CkZipCrc_BeginStream($this->_cPtr);
	}

	function CalculateCrc($data) {
		return CkZipCrc_CalculateCrc($this->_cPtr,$data);
	}

	function CrcBd($bd) {
		return CkZipCrc_CrcBd($this->_cPtr,$bd);
	}

	function CrcSb($sb,$charset) {
		return CkZipCrc_CrcSb($this->_cPtr,$sb,$charset);
	}

	function CrcString($str,$charset) {
		return CkZipCrc_CrcString($this->_cPtr,$str,$charset);
	}

	function EndStream() {
		return CkZipCrc_EndStream($this->_cPtr);
	}

	function FileCrc($path) {
		return CkZipCrc_FileCrc($this->_cPtr,$path);
	}

	function FileCrcAsync($path) {
		$r=CkZipCrc_FileCrcAsync($this->_cPtr,$path);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkZipCrc_LoadTaskCaller($this->_cPtr,$task);
	}

	function MoreData($data) {
		CkZipCrc_MoreData($this->_cPtr,$data);
	}

	function toHex($crc) {
		return CkZipCrc_toHex($this->_cPtr,$crc);
	}
}

class CkZipEntry {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_chilkat_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __get($var) {
		if ($var === 'thisown') return swig_chilkat_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __construct($res=null) {
		if (is_resource($res) && get_resource_type($res) === '_p_CkZipEntry') {
			$this->_cPtr=$res;
			return;
		}
		$this->_cPtr=new_CkZipEntry();
	}

	function get_Utf8() {
		return CkZipEntry_get_Utf8($this->_cPtr);
	}

	function put_Utf8($b) {
		CkZipEntry_put_Utf8($this->_cPtr,$b);
	}

	function put_EventCallbackObject($progress) {
		CkZipEntry_put_EventCallbackObject($this->_cPtr,$progress);
	}

	function get_Comment($str) {
		CkZipEntry_get_Comment($this->_cPtr,$str);
	}

	function comment() {
		return CkZipEntry_comment($this->_cPtr);
	}

	function put_Comment($newVal) {
		CkZipEntry_put_Comment($this->_cPtr,$newVal);
	}

	function get_CompressedLength() {
		return CkZipEntry_get_CompressedLength($this->_cPtr);
	}

	function get_CompressedLength64() {
		return CkZipEntry_get_CompressedLength64($this->_cPtr);
	}

	function get_CompressedLengthStr($str) {
		CkZipEntry_get_CompressedLengthStr($this->_cPtr,$str);
	}

	function compressedLengthStr() {
		return CkZipEntry_compressedLengthStr($this->_cPtr);
	}

	function get_CompressionLevel() {
		return CkZipEntry_get_CompressionLevel($this->_cPtr);
	}

	function put_CompressionLevel($newVal) {
		CkZipEntry_put_CompressionLevel($this->_cPtr,$newVal);
	}

	function get_CompressionMethod() {
		return CkZipEntry_get_CompressionMethod($this->_cPtr);
	}

	function put_CompressionMethod($newVal) {
		CkZipEntry_put_CompressionMethod($this->_cPtr,$newVal);
	}

	function get_Crc() {
		return CkZipEntry_get_Crc($this->_cPtr);
	}

	function get_DebugLogFilePath($str) {
		CkZipEntry_get_DebugLogFilePath($this->_cPtr,$str);
	}

	function debugLogFilePath() {
		return CkZipEntry_debugLogFilePath($this->_cPtr);
	}

	function put_DebugLogFilePath($newVal) {
		CkZipEntry_put_DebugLogFilePath($this->_cPtr,$newVal);
	}

	function get_EncryptionKeyLen() {
		return CkZipEntry_get_EncryptionKeyLen($this->_cPtr);
	}

	function get_EntryID() {
		return CkZipEntry_get_EntryID($this->_cPtr);
	}

	function get_EntryType() {
		return CkZipEntry_get_EntryType($this->_cPtr);
	}

	function get_FileDateTimeStr($str) {
		CkZipEntry_get_FileDateTimeStr($this->_cPtr,$str);
	}

	function fileDateTimeStr() {
		return CkZipEntry_fileDateTimeStr($this->_cPtr);
	}

	function put_FileDateTimeStr($newVal) {
		CkZipEntry_put_FileDateTimeStr($this->_cPtr,$newVal);
	}

	function get_FileName($str) {
		CkZipEntry_get_FileName($this->_cPtr,$str);
	}

	function fileName() {
		return CkZipEntry_fileName($this->_cPtr);
	}

	function put_FileName($newVal) {
		CkZipEntry_put_FileName($this->_cPtr,$newVal);
	}

	function get_FileNameHex($str) {
		CkZipEntry_get_FileNameHex($this->_cPtr,$str);
	}

	function fileNameHex() {
		return CkZipEntry_fileNameHex($this->_cPtr);
	}

	function get_HeartbeatMs() {
		return CkZipEntry_get_HeartbeatMs($this->_cPtr);
	}

	function put_HeartbeatMs($newVal) {
		CkZipEntry_put_HeartbeatMs($this->_cPtr,$newVal);
	}

	function get_IsAesEncrypted() {
		return CkZipEntry_get_IsAesEncrypted($this->_cPtr);
	}

	function get_IsDirectory() {
		return CkZipEntry_get_IsDirectory($this->_cPtr);
	}

	function get_LastErrorHtml($str) {
		CkZipEntry_get_LastErrorHtml($this->_cPtr,$str);
	}

	function lastErrorHtml() {
		return CkZipEntry_lastErrorHtml($this->_cPtr);
	}

	function get_LastErrorText($str) {
		CkZipEntry_get_LastErrorText($this->_cPtr,$str);
	}

	function lastErrorText() {
		return CkZipEntry_lastErrorText($this->_cPtr);
	}

	function get_LastErrorXml($str) {
		CkZipEntry_get_LastErrorXml($this->_cPtr,$str);
	}

	function lastErrorXml() {
		return CkZipEntry_lastErrorXml($this->_cPtr);
	}

	function get_LastMethodSuccess() {
		return CkZipEntry_get_LastMethodSuccess($this->_cPtr);
	}

	function put_LastMethodSuccess($newVal) {
		CkZipEntry_put_LastMethodSuccess($this->_cPtr,$newVal);
	}

	function get_TextFlag() {
		return CkZipEntry_get_TextFlag($this->_cPtr);
	}

	function put_TextFlag($newVal) {
		CkZipEntry_put_TextFlag($this->_cPtr,$newVal);
	}

	function get_UncompressedLength() {
		return CkZipEntry_get_UncompressedLength($this->_cPtr);
	}

	function get_UncompressedLength64() {
		return CkZipEntry_get_UncompressedLength64($this->_cPtr);
	}

	function get_UncompressedLengthStr($str) {
		CkZipEntry_get_UncompressedLengthStr($this->_cPtr,$str);
	}

	function uncompressedLengthStr() {
		return CkZipEntry_uncompressedLengthStr($this->_cPtr);
	}

	function get_VerboseLogging() {
		return CkZipEntry_get_VerboseLogging($this->_cPtr);
	}

	function put_VerboseLogging($newVal) {
		CkZipEntry_put_VerboseLogging($this->_cPtr,$newVal);
	}

	function get_Version($str) {
		CkZipEntry_get_Version($this->_cPtr,$str);
	}

	function version() {
		return CkZipEntry_version($this->_cPtr);
	}

	function AppendData($inData) {
		return CkZipEntry_AppendData($this->_cPtr,$inData);
	}

	function AppendDataAsync($inData) {
		$r=CkZipEntry_AppendDataAsync($this->_cPtr,$inData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function AppendString($strContent,$charset) {
		return CkZipEntry_AppendString($this->_cPtr,$strContent,$charset);
	}

	function AppendStringAsync($strContent,$charset) {
		$r=CkZipEntry_AppendStringAsync($this->_cPtr,$strContent,$charset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function Copy($outData) {
		return CkZipEntry_Copy($this->_cPtr,$outData);
	}

	function copyToBase64() {
		return CkZipEntry_copyToBase64($this->_cPtr);
	}

	function copyToHex() {
		return CkZipEntry_copyToHex($this->_cPtr);
	}

	function Extract($dirPath) {
		return CkZipEntry_Extract($this->_cPtr,$dirPath);
	}

	function ExtractAsync($dirPath) {
		$r=CkZipEntry_ExtractAsync($this->_cPtr,$dirPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function ExtractInto($dirPath) {
		return CkZipEntry_ExtractInto($this->_cPtr,$dirPath);
	}

	function ExtractIntoAsync($dirPath) {
		$r=CkZipEntry_ExtractIntoAsync($this->_cPtr,$dirPath);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function GetDt() {
		$r=CkZipEntry_GetDt($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkDateTime($r);
		}
		return $r;
	}

	function GetNext() {
		return CkZipEntry_GetNext($this->_cPtr);
	}

	function GetNextMatch($pattern) {
		return CkZipEntry_GetNextMatch($this->_cPtr,$pattern);
	}

	function Inflate($outData) {
		return CkZipEntry_Inflate($this->_cPtr,$outData);
	}

	function InflateAsync() {
		$r=CkZipEntry_InflateAsync($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function LoadTaskCaller($task) {
		return CkZipEntry_LoadTaskCaller($this->_cPtr,$task);
	}

	function NextEntry() {
		$r=CkZipEntry_NextEntry($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function NextMatchingEntry($matchStr) {
		$r=CkZipEntry_NextMatchingEntry($this->_cPtr,$matchStr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkZipEntry($r);
		}
		return $r;
	}

	function ReplaceData($inData) {
		return CkZipEntry_ReplaceData($this->_cPtr,$inData);
	}

	function ReplaceString($strContent,$charset) {
		return CkZipEntry_ReplaceString($this->_cPtr,$strContent,$charset);
	}

	function SetDt($dt) {
		CkZipEntry_SetDt($this->_cPtr,$dt);
	}

	function UnzipToBd($binData) {
		return CkZipEntry_UnzipToBd($this->_cPtr,$binData);
	}

	function UnzipToBdAsync($binData) {
		$r=CkZipEntry_UnzipToBdAsync($this->_cPtr,$binData);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UnzipToSb($lineEndingBehavior,$srcCharset,$sb) {
		return CkZipEntry_UnzipToSb($this->_cPtr,$lineEndingBehavior,$srcCharset,$sb);
	}

	function UnzipToSbAsync($lineEndingBehavior,$srcCharset,$sb) {
		$r=CkZipEntry_UnzipToSbAsync($this->_cPtr,$lineEndingBehavior,$srcCharset,$sb);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function UnzipToStream($toStream) {
		return CkZipEntry_UnzipToStream($this->_cPtr,$toStream);
	}

	function UnzipToStreamAsync($toStream) {
		$r=CkZipEntry_UnzipToStreamAsync($this->_cPtr,$toStream);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}

	function unzipToString($lineEndingBehavior,$srcCharset) {
		return CkZipEntry_unzipToString($this->_cPtr,$lineEndingBehavior,$srcCharset);
	}

	function UnzipToStringAsync($lineEndingBehavior,$srcCharset) {
		$r=CkZipEntry_UnzipToStringAsync($this->_cPtr,$lineEndingBehavior,$srcCharset);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new CkTask($r);
		}
		return $r;
	}
}


?>
